SslStream SslStream SslStream SslStream Class

Definition

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. Provides a stream used for client-server communication that uses the Secure Socket Layer (SSL) security protocol to authenticate the server and optionally the client.

public ref class SslStream : System::Net::Security::AuthenticatedStream
public class SslStream : System.Net.Security.AuthenticatedStream
type SslStream = class
    inherit AuthenticatedStream
    interface IDisposable
Public Class SslStream
Inherits AuthenticatedStream
Vererbung

Beispiele

Das folgende Codebeispiel veranschaulicht das Erstellen einer TcpListener , verwendet der SslStream Klasse, um die Kommunikation mit Clients.The following code example demonstrates creating an TcpListener that uses the SslStream class to communicate with clients.

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

Das folgende Codebeispiel veranschaulicht das Erstellen einer TcpClient , verwendet der SslStream Klasse, um die Kommunikation mit dem Server.The following code example demonstrates creating a TcpClient that uses the SslStream class to communicate with a server.

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

Hinweise

SSL-Protokolle zu helfen, Vertraulichkeit und Integrität überprüfen auf Nachrichten, die mithilfe der übertragen zu einer SslStream.SSL protocols help to provide confidentiality and integrity checking for messages transmitted using an SslStream. Eine SSL-Verbindung, z. B. über SslStream, sollten werden verwendet, wenn Kommunikation vertrauliche Informationen zwischen einem Client und einem Server.An SSL connection, such as that provided by SslStream, should be used when communicating sensitive information between a client and a server. Verwenden einer SslStream können, um zu verhindern, dass jemand aus lesen und Manipulieren von Informationen während der Übertragung im Netzwerk.Using an SslStream helps to prevent anyone from reading and tampering with information while it is in transit on the network.

Ein SslStream -Instanz überträgt Daten mithilfe eines Datenstroms, die Sie, beim Erstellen angeben der SslStream.An SslStream instance transmits data using a stream that you supply when creating the SslStream. Wenn Sie diese zugrunde liegenden Stream bereitstellen, haben Sie die Option zur Angabe, ob durch Schließen der SslStream auch die zugrunde liegende Stream geschlossen wird.When you supply this underlying stream, you have the option to specify whether closing the SslStream also closes the underlying stream. In der Regel die SslStream -Klasse wird zusammen mit den TcpClient und TcpListener Klassen.Typically, the SslStream class is used with the TcpClient and TcpListener classes. Die GetStream Methode bietet eine NetworkStream geeignet für die Verwendung mit der SslStream Klasse.The GetStream method provides a NetworkStream suitable for use with the SslStream class.

Nach dem Erstellen einer SslStream, den Server und optional des Clients authentifiziert werden müssen.After creating an SslStream, the server and optionally, the client must be authenticated. Der Server muss ein X509 bereitstellen Zertifikat, richtet der Nachweis der Identität und kann anfordern, dass der Client auch dies tun.The server must provide an X509 certificate that establishes proof of its identity and can request that the client also do so. Authentifizierung muss ausgeführt werden, vor der Übertragung von Informationen mithilfe einer SslStream.Authentication must be performed before transmitting information using an SslStream. Clients initiieren die Authentifizierung mit den synchronen AuthenticateAsClient Methoden, die blockiert, bis die Authentifizierung abgeschlossen ist, oder die asynchrone BeginAuthenticateAsClient -Methoden, die Wartezeit für die Authentifizierung abgeschlossen nicht blockieren.Clients initiate authentication using the synchronous AuthenticateAsClient methods, which block until the authentication completes, or the asynchronous BeginAuthenticateAsClient methods, which do not block waiting for the authentication to complete. Server initiieren die Authentifizierung mit den synchronen AuthenticateAsServer oder asynchrone BeginAuthenticateAsServer Methoden.Servers initiate authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. Sowohl Client-als auch müssen die Authentifizierung initiiert werden.Both client and server must initiate the authentication.

Die Authentifizierung erfolgt über die Security Support Provider (SSPI)-Channelanbieter.The authentication is handled by the Security Support Provider (SSPI) channel provider. Der Client erhält eine Möglichkeit zum Steuern der Überprüfung des Serverzertifikats durch Angabe einer RemoteCertificateValidationCallback delegieren Sie beim Erstellen einer SslStream.The client is given an opportunity to control validation of the server's certificate by specifying a RemoteCertificateValidationCallback delegate when creating an SslStream. Der Server kann auch die Überprüfung steuern, durch Angabe einer RemoteCertificateValidationCallback delegieren.The server can also control validation by supplying a RemoteCertificateValidationCallback delegate. Die Methode, die auf die verwiesen wird durch den Delegaten enthält, der remote-Teilnehmer-Zertifikat und alle Fehler SSPI, die bei der Überprüfung des Zertifikats gefunden.The method referenced by the delegate includes the remote party's certificate and any errors SSPI encountered while validating the certificate. Beachten Sie, dass wenn der Server einen Delegaten angibt, die-Methode des Delegaten so aufgerufen wird, unabhängig davon, ob der Server für die Clientauthentifizierung angefordert.Note that if the server specifies a delegate, the delegate's method is invoked regardless of whether the server requested client authentication. Wenn der Server nicht die Clientauthentifizierung angefordert hat, empfängt Delegatmethode des Servers ein null-Zertifikat und ein leeres Array vom Zertifikatfehler auftreten.If the server did not request client authentication, the server's delegate method receives a null certificate and an empty array of certificate errors.

Wenn der Server die Client-Authentifizierung erfordert, muss der Client ein oder mehrere Zertifikate für die Authentifizierung angeben.If the server requires client authentication, the client must specify one or more certificates for authentication. 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.If the client has more than one certificate, the client can provide a LocalCertificateSelectionCallback delegate to select the correct certificate for the server. Die Zertifikate des Clients müssen sich im des aktuellen Benutzers "My"-Zertifikatspeicher befinden.The client's certificates must be located in the current user's "My" certificate store. Die Clientauthentifizierung über Zertifikate wird nicht unterstützt, für die Ssl2 -Protokoll (SSL-Version 2).Client authentication via certificates is not supported for the Ssl2 (SSL version 2) protocol.

Wenn die Authentifizierung fehlschlägt, erhalten Sie eine AuthenticationException, und die SslStream ist nicht mehr funktionsfähig.If the authentication fails, you receive a AuthenticationException, and the SslStream is no longer useable. Sie dieses Objekt schließen, und entfernen alle Verweise darauf, sodass es vom Garbage Collector gesammelt werden kann.You should close this object and remove all references to it so that it can be collected by the garbage collector.

Wenn die Authentifizierung, auch bekannt als SSL-Handshake, erfolgreich ist, wird die Identität des Servers (und optional des Clients) hergestellt und die SslStream zum Austausch von Nachrichten vom Client und Server verwendet werden können.When the authentication process, also known as the SSL handshake, succeeds, the identity of the server (and optionally, the client) is established and the SslStream can be used by the client and server to exchange messages. Vor dem Senden oder Empfangen von Informationen, Client und Server sollte überprüfen Sie die Sicherheitsdienste und Ebenen, die bereitgestellt werden, indem die SslStream zu bestimmen, ob das Protokoll, Algorithmen und Stärken ausgewählt ihre Anforderungen an Integrität erfüllt und Vertraulichkeit.Before sending or receiving information, the client and server should check the security services and levels provided by the SslStream to determine whether the protocol, algorithms, and strengths selected meet their requirements for integrity and confidentiality. Wenn die aktuellen Einstellungen nicht ausreichend sind, sollte der Stream geschlossen werden.If the current settings are not sufficient, the stream should be closed. Sehen Sie sich die Sicherheitsdienste gebotenen die SslStream mithilfe der IsEncrypted und IsSigned Eigenschaften.You can check the security services provided by the SslStream using the IsEncrypted and IsSigned properties. Die folgende Tabelle zeigt die Elemente, die die kryptografischen Einstellungen für die Authentifizierung, Verschlüsselung und Unterzeichnung von Daten zu melden.The following table shows the elements that report the cryptographic settings used for authentication, encryption and data signing.

ElementElement MemberMembers
Das Sicherheitsprotokoll verwendet, um den Server und optional des Clients zu authentifizieren.The security protocol used to authenticate the server and, optionally, the client. Die SslProtocol -Eigenschaft und den zugehörigen SslProtocols Enumeration.The SslProtocol property and the associated SslProtocols enumeration.
Der Schlüsselaustauschalgorithmus.The key exchange algorithm. Die KeyExchangeAlgorithm -Eigenschaft und den zugehörigen ExchangeAlgorithmType Enumeration.The KeyExchangeAlgorithm property and the associated ExchangeAlgorithmType enumeration.
Algorithmus für die Integrität.The message integrity algorithm. Die HashAlgorithm -Eigenschaft und den zugehörigen HashAlgorithmType Enumeration.The HashAlgorithm property and the associated HashAlgorithmType enumeration.
Algorithmus für die Vertraulichkeit.The message confidentiality algorithm. Die CipherAlgorithm -Eigenschaft und den zugehörigen CipherAlgorithmType Enumeration.The CipherAlgorithm property and the associated CipherAlgorithmType enumeration.
Die Stärken der ausgewählten Algorithmen.The strengths of the selected algorithms. Die KeyExchangeStrength, HashStrength, und CipherStrength Eigenschaften.The KeyExchangeStrength, HashStrength, and CipherStrength properties.

Nach der erfolgreichen Authentifizierung, können Sie Daten, die mit den synchronen senden Write oder asynchrone BeginWrite Methoden.After a successful authentication, you can send data using the synchronous Write or asynchronous BeginWrite methods. Empfangen von Daten, die mit den synchronen Read oder asynchrone BeginRead Methoden.You can receive data using the synchronous Read or asynchronous BeginRead methods.

Wenn Sie angegeben haben, um die SslStream , dass der zugrunde liegende Stream sollte geöffnet bleiben, Sie sind verantwortlich für den Stream schließen, wenn Sie fertig sind verwenden.If you specified to the SslStream that the underlying stream should be left open, you are responsible for closing that stream when you are done using it.

Hinweis

Wenn die Anwendung erstellt wird, die die SslStream Objekt mit den Anmeldeinformationen eines Standardbenutzers ausgeführt wird, die Anwendung wird nicht in der Lage, auf Zertifikate im Speicher lokalen Computers installiert werden, es sei denn, die Berechtigung dazu explizit für den Benutzer angegeben wurde.If the application that creates the SslStream object runs with the credentials of a Normal user, the application will not be able to access certificates installed in the local machine store unless permission has been explicitly given to the user to do so.

SslStream setzt voraus, dass ein Timeout zusammen mit anderen IOException bei einem ausgelöst wird, vom inneren Datenstrom behandelt werden als schwerwiegend durch den Aufrufer.SslStream assumes that a timeout along with any other IOException when one is thrown from the inner stream will be treated as fatal by its caller. Wiederverwenden von einem SslStream -Instanz nach ein Timeout Garbage zurückgibt.Reusing a SslStream instance after a timeout will return garbage. Eine Anwendung sollte Close der SslStream und löst eine Ausnahme in diesen Fällen.An application should Close the SslStream and throw an exception in these cases.

.NET Framework 4.6 umfasst eine neue Sicherheitsfunktion, die unsichere Verschlüsselung und Hashalgorithmen für Verbindungen blockiert.The .NET Framework 4.6 includes a new security feature that blocks insecure cipher and hashing algorithms for connections. Mithilfe von TLS/SSL über APIs wie z. B. "HttpClient", "HttpWebRequest", FTPClient, SmtpClient, SslStream usw. und als Ziel .NET Framework 4.6-Anwendungen das sicherere Verhalten wird standardmäßig abgerufen.Applications using TLS/SSL through APIs such as HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream, etc. and targeting .NET Framework 4.6 get the more-secure behavior by default.

Entwickler sollten dieses Verhalten abwählen, um die Interoperabilität mit ihren vorhandenen SSL3-Diensten oder TLS mit RC4-Dienste zu gewährleisten.Developers may want to opt out of this behavior in order to maintain interoperability with their existing SSL3 services OR TLS w/ RC4 services. In diesem Artikel wird erläutert, wie Sie Ihren Code ändern, sodass das neue Verhalten deaktiviert ist.This article explains how to modify your code so that the new behavior is disabled.

.NET Framework 4.7 fügt neue Überladungen für die Methoden, die SslStreams zu, die die TLS-Version als Systemstandard im definierte verwenden authentifizieren, sondern geben Sie eine TLS-Version nicht SCHANNEL.The .NET Framework 4.7 adds new overloads for the methods that authenticate SslStreams that do not specify a TLS version, but instead use the TLS version defined as the system default in SCHANNEL. Verwenden Sie diese Methoden in Ihrer app als eine Möglichkeit, die später ändern, die Standardeinstellungen als TLS Version best-Practice-Änderungen im Laufe der Zeit können brauchen nicht neu erstellen und Bereitstellen Ihrer app.Use these methods in your app as a way to be able to later modify the defaults as TLS version best practice changes over time, without the need to rebuild and redeploy your app.

Siehe auch Transport Layer Security (TLS) best Practices mit .NET Framework.Also see Transport Layer Security (TLS) best practices with the .NET Framework.

Konstruktoren

SslStream(Stream) SslStream(Stream) SslStream(Stream) SslStream(Stream)

Initialisiert eine neue Instanz der SslStream-Klasse mit dem angegebenen Stream. Initializes a new instance of the SslStream class using the specified Stream.

SslStream(Stream, Boolean) SslStream(Stream, Boolean) SslStream(Stream, Boolean) SslStream(Stream, Boolean)

Verwendet den angegebenen SslStream und das Schlussverhalten des Streams zum Initialisieren einer neuen Instanz der Stream-Klasse. Initializes a new instance of the SslStream class using the specified Stream and stream closure behavior.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback) SslStream(Stream, Boolean, RemoteCertificateValidationCallback) SslStream(Stream, Boolean, RemoteCertificateValidationCallback) 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. Initializes a new instance of the SslStream class using the specified Stream, stream closure behavior and certificate validation delegate.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback) SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback) SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback) 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. Initializes a new instance of the SslStream class using the specified Stream, stream closure behavior, certificate validation delegate and certificate selection delegate.

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

Initialisiert eine neue Instanz der SslStream-Klasse mit der angegebenen Stream. Initializes a new instance of the SslStream class using the specified Stream

Eigenschaften

CanRead CanRead CanRead CanRead

Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream gelesen werden kann. Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek CanSeek CanSeek CanSeek

Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream durchsucht werden kann. Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout CanTimeout CanTimeout CanTimeout

Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream Timeouts unterstützt. Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite CanWrite CanWrite CanWrite

Ruft einen Boolean-Wert ab, der angibt, ob im zugrunde liegenden Stream geschrieben werden kann. Gets a Boolean value that indicates whether the underlying stream is writable.

CheckCertRevocationStatus CheckCertRevocationStatus CheckCertRevocationStatus CheckCertRevocationStatus

Ruft einen Boolean-Wert ab, der angibt, ob die Zertifikatssperrliste während der Zertifikatsvalidierung überprüft wird. Gets a Boolean value that indicates whether the certificate revocation list is checked during the certificate validation process.

CipherAlgorithm CipherAlgorithm CipherAlgorithm CipherAlgorithm

Ruft einen Wert ab, der den von diesem SslStream verwendeten Sammelverschlüsselungsalgorithmus angibt. Gets a value that identifies the bulk encryption algorithm used by this SslStream.

CipherStrength CipherStrength CipherStrength CipherStrength

Ruft einen Wert ab, der die Stärke des von diesem SslStream verwendeten Verschlüsselungsverfahrensalgorithmus angibt. Gets a value that identifies the strength of the cipher algorithm used by this SslStream.

HashAlgorithm HashAlgorithm HashAlgorithm HashAlgorithm

Ruft den für das Generieren von Message Authentication Codes (MAC – Nachrichtenauthentifizierungscode) verwendeten Algorithmus an. Gets the algorithm used for generating message authentication codes (MACs).

HashStrength HashStrength HashStrength HashStrength

Ruft einen Wert ab, der die Stärke des von dieser Instanz verwendeten Hashalgorithmus angibt. Gets a value that identifies the strength of the hash algorithm used by this instance.

InnerStream InnerStream InnerStream InnerStream

Ruft den von diesem AuthenticatedStream verwendeten Stream zum Senden und Empfangen von Daten ab. Gets the stream used by this AuthenticatedStream for sending and receiving data.

(Inherited from AuthenticatedStream)
IsAuthenticated IsAuthenticated IsAuthenticated IsAuthenticated

Ruft einen Boolean-Wert ab, der angibt, ob die Authentifizierung erfolgreich war. Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted IsEncrypted IsEncrypted IsEncrypted

Ruft einen Boolean-Wert ab, der angibt, ob dieser SslStream verschlüsselte Daten verwendet. Gets a Boolean value that indicates whether this SslStream uses data encryption.

IsMutuallyAuthenticated IsMutuallyAuthenticated IsMutuallyAuthenticated IsMutuallyAuthenticated

Ruft einen Boolean-Wert ab, der angibt, ob sowohl Client als auch Server authentifiziert wurden. Gets a Boolean value that indicates whether both server and client have been authenticated.

IsServer IsServer IsServer IsServer

Ruft einen Boolean-Wert ab, der angibt, ob die lokale, von diesem SslStream verwendete Seite der Verbindung als Server authentifiziert wurde. Gets a Boolean value that indicates whether the local side of the connection used by this SslStream was authenticated as the server.

IsSigned IsSigned IsSigned IsSigned

Ruft einen Boolean-Wert ab, der angibt, ob die mit diesem Stream gesendeten Daten signiert sind. Gets a Boolean value that indicates whether the data sent using this stream is signed.

KeyExchangeAlgorithm KeyExchangeAlgorithm KeyExchangeAlgorithm KeyExchangeAlgorithm

Ruft den von diesem SslStream verwendeten Schlüsselaustauschalgorithmus ab. Gets the key exchange algorithm used by this SslStream.

KeyExchangeStrength KeyExchangeStrength KeyExchangeStrength KeyExchangeStrength

Ruft einen Wert ab, der die Stärke des von dieser Instanz verwendeten Schlüsselaustauschalgorithmus angibt. Gets a value that identifies the strength of the key exchange algorithm used by this instance.

LeaveInnerStreamOpen LeaveInnerStreamOpen LeaveInnerStreamOpen LeaveInnerStreamOpen

Ruft ab, ob der zum Senden und Empfangen von Daten von diesem AuthenticatedStream verwendete Stream weiterhin geöffnet ist. Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(Inherited from AuthenticatedStream)
Length Length Length Length

Ruft die Länge des zugrunde liegenden Streams ab. Gets the length of the underlying stream.

LocalCertificate LocalCertificate LocalCertificate LocalCertificate

Ruft das Zertifikat ab, mit dem der lokale Endpunkt authentifiziert wird. Gets the certificate used to authenticate the local endpoint.

NegotiatedApplicationProtocol NegotiatedApplicationProtocol NegotiatedApplicationProtocol NegotiatedApplicationProtocol
Position Position Position Position

Ruft die aktuelle Position im zugrunde liegenden Stream ab oder legt diese fest. Gets or sets the current position in the underlying stream.

ReadTimeout ReadTimeout ReadTimeout ReadTimeout

Ruft die Zeitspanne ab, in der ein Lesevorgang während des Wartens auf Daten blockiert wird, oder legt diese fest. Gets or sets the amount of time a read operation blocks waiting for data.

RemoteCertificate RemoteCertificate RemoteCertificate RemoteCertificate

Ruft das Zertifikat ab, mit dem der Remoteendpunkt authentifiziert wird. Gets the certificate used to authenticate the remote endpoint.

SslProtocol SslProtocol SslProtocol SslProtocol

Ruft einen Wert ab, der das zum Authentifizieren dieser Verbindung verwendete Sicherheitsprotokoll angibt. Gets a value that indicates the security protocol used to authenticate this connection.

TransportContext TransportContext TransportContext TransportContext

Ruft das für die Authentifizierung mit erweitertem Schutz verwendete TransportContext ab. Gets the TransportContext used for authentication using extended protection.

WriteTimeout WriteTimeout WriteTimeout WriteTimeout

Ruft die Zeitspanne ab, in der ein Schreibvorgang während des Wartens auf Daten blockiert wird, oder legt diese fest. Gets or sets the amount of time a write operation blocks waiting for data.

Methoden

AuthenticateAsClient(String) AuthenticateAsClient(String) AuthenticateAsClient(String) AuthenticateAsClient(String)

Wird von Clients zur Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Called by clients to authenticate the server and optionally the client in a client-server connection.

AuthenticateAsClient(String, X509CertificateCollection, Boolean) AuthenticateAsClient(String, X509CertificateCollection, Boolean) AuthenticateAsClient(String, X509CertificateCollection, Boolean) AuthenticateAsClient(String, X509CertificateCollection, Boolean)

Wird von Clients zur Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Called by clients to authenticate the server and optionally the client in a client-server connection. Der Authentifizierungsprozess verwendet die angegebene Zertifikatsammlung und das SSL-Standardprotokoll des Systems. The authentication process uses the specified certificate collection, and the system default SSL protocol.

AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean) AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean) AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean) AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)

Wird von Clients zur Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Called by clients to authenticate the server and optionally the client in a client-server connection. Beim Authentifizierungsvorgang werden die angegebene Zertifikatsauflistung und das SSL-Protokoll verwendet. The authentication process uses the specified certificate collection and SSL protocol.

AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken) AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken) AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken) AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)
AuthenticateAsClientAsync(String) AuthenticateAsClientAsync(String) AuthenticateAsClientAsync(String) AuthenticateAsClientAsync(String)

Wird von Clients zur asynchronen Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean) AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean) AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean) AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)

Wird von Clients zur asynchronen Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Der Authentifizierungsprozess verwendet die angegebene Zertifikatsammlung und das SSL-Standardprotokoll des Systems. The authentication process uses the specified certificate collection and the system default SSL protocol.

AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean) AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean) AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean) AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)

Wird von Clients zur asynchronen Authentifizierung des Servers und optional des Clients in einer Client-Server-Verbindung verwendet. Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Beim Authentifizierungsvorgang werden die angegebene Zertifikatsauflistung und das SSL-Protokoll verwendet. The authentication process uses the specified certificate collection and SSL protocol.

AuthenticateAsServer(X509Certificate) AuthenticateAsServer(X509Certificate) AuthenticateAsServer(X509Certificate) AuthenticateAsServer(X509Certificate)

Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Servers und optional auch des Clients mit dem angegebenen Zertifikat aufgerufen. Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificate.

AuthenticateAsServer(X509Certificate, Boolean, Boolean) AuthenticateAsServer(X509Certificate, Boolean, Boolean) AuthenticateAsServer(X509Certificate, Boolean, Boolean) 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. Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates and requirements, and using the sytem default security protocol.

AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean) AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean) AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean) 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. Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates, requirements and security protocol.

AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken) AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken) AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken) AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)
AuthenticateAsServerAsync(X509Certificate) AuthenticateAsServerAsync(X509Certificate) AuthenticateAsServerAsync(X509Certificate) 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. Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificate as an asynchronous operation.

AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean) AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean) AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean) 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. Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates, requirements and security protocol as an asynchronous operation.

AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean) AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean) AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean) 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. Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates, requirements and security protocol as an asynchronous operation.

BeginAuthenticateAsClient(String, AsyncCallback, Object) BeginAuthenticateAsClient(String, AsyncCallback, Object) BeginAuthenticateAsClient(String, AsyncCallback, Object) BeginAuthenticateAsClient(String, AsyncCallback, Object)

Wird von Clients aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Servers und optional auch des Clients zu starten. Called by clients to begin an asynchronous operation to authenticate the server and optionally the client.

BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object) BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object) BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object) 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. Called by clients to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates and the system default security protocol.

BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object) BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object) BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object) 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. Called by clients to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates and security protocol.

BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object) BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object) BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object) 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. Called by servers to begin an asynchronous operation to authenticate the client and optionally the server in a client-server connection.

BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object) BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object) BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object) 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. Called by servers to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates and requirements, and the system default security protocol.

BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object) BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object) BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object) 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. Called by servers to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates, requirements and security protocol.

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

Startet einen asynchronen Lesevorgang, der Daten aus dem Stream liest und im angegebenen Array speichert. Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

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

Startet einen asynchronen Schreibvorgang, der Byte vom angegebenen Puffer in den Stream schreibt. Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

Close() Close() Close() Close()

Schließt den aktuellen Stream und gibt alle dem aktuellen Stream zugeordneten Ressourcen frei (z. B. Sockets und Dateihandles). Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Anstatt diese Methode aufzurufen, stellen Sie sicher, dass der Stream ordnungsgemäß freigegeben wird. Instead of calling this method, ensure that the stream is properly disposed.

(Inherited from Stream)
CopyTo(Stream) CopyTo(Stream) CopyTo(Stream) CopyTo(Stream)

Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. Reads the bytes from the current stream and writes them to another stream.

(Inherited from Stream)
CopyTo(Stream, Int32) CopyTo(Stream, Int32) CopyTo(Stream, Int32) CopyTo(Stream, Int32)

Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Inherited from Stream)
CopyToAsync(Stream) CopyToAsync(Stream) CopyToAsync(Stream) CopyToAsync(Stream)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. Asynchronously reads the bytes from the current stream and writes them to another stream.

(Inherited from Stream)
CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken) Inherited from Stream
CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Inherited from Stream)
CopyToAsync(Stream, Int32, CancellationToken) CopyToAsync(Stream, Int32, CancellationToken) CopyToAsync(Stream, Int32, CancellationToken) 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. Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(Inherited from Stream)
CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
CreateWaitHandle() CreateWaitHandle() CreateWaitHandle() CreateWaitHandle()

Reserviert ein WaitHandle-Objekt. Allocates a WaitHandle object.

(Inherited from Stream)
Dispose() Dispose() Dispose() Dispose()

Gibt alle vom Stream verwendeten Ressourcen frei. Releases all resources used by the Stream.

(Inherited from Stream)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Gibt die von SslStream verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. Releases the unmanaged resources used by the SslStream and optionally releases the managed resources.

EndAuthenticateAsClient(IAsyncResult) EndAuthenticateAsClient(IAsyncResult) EndAuthenticateAsClient(IAsyncResult) EndAuthenticateAsClient(IAsyncResult)

Beendet einen ausstehenden asynchronen Serverauthentifizierungsvorgang, der mit einem vorhergehenden Aufruf von BeginAuthenticateAsClient gestartet wurde. Ends a pending asynchronous server authentication operation started with a previous call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult) EndAuthenticateAsServer(IAsyncResult) EndAuthenticateAsServer(IAsyncResult) EndAuthenticateAsServer(IAsyncResult)

Beendet einen ausstehenden asynchronen Clientauthentifizierungsvorgang, der mit einem vorherigen Aufruf von BeginAuthenticateAsClient gestartet wird. Ends a pending asynchronous client authentication operation started with a previous call to BeginAuthenticateAsClient.

EndRead(IAsyncResult) EndRead(IAsyncResult) EndRead(IAsyncResult) EndRead(IAsyncResult)

Beendet einen asynchronen mit einem vorhergehenden Aufruf von BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) gestarteten Lesevorgang. Ends an asynchronous read operation started with a previous call to BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).

EndWrite(IAsyncResult) EndWrite(IAsyncResult) EndWrite(IAsyncResult) EndWrite(IAsyncResult)

Beendet einen asynchronen mit einem vorhergehenden Aufruf von BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) gestarteten Schreibvorgang. Ends an asynchronous write operation started with a previous call to BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. Determines whether the specified object is equal to the current object.

(Inherited from Object)
Flush() Flush() Flush() Flush()

Veranlasst das Schreiben aller gepufferten Daten in das zugrunde liegende Gerät. Causes any buffered data to be written to the underlying device.

FlushAsync() FlushAsync() FlushAsync() FlushAsync()

Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Inherited from Stream)
FlushAsync(CancellationToken) FlushAsync(CancellationToken) FlushAsync(CancellationToken) FlushAsync(CancellationToken)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als die Standardhashfunktion. Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab. Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object. Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
ObjectInvariant() ObjectInvariant() ObjectInvariant() ObjectInvariant()

Bietet Unterstützung für einen Contract. Provides support for a Contract.

(Inherited from Stream)
Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32)

Liest Daten aus diesem Stream und speichert sie im angegebenen Array. Reads data from this stream and stores it in the specified array.

Read(Span<Byte>) Read(Span<Byte>) Read(Span<Byte>) Read(Span<Byte>) Inherited from Stream
ReadAsync(Byte[], Int32, Int32) ReadAsync(Byte[], Int32, Int32) ReadAsync(Byte[], Int32, Int32) 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. Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Inherited from Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken) ReadAsync(Byte[], Int32, Int32, CancellationToken) ReadAsync(Byte[], Int32, Int32, CancellationToken) ReadAsync(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. Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

(Inherited from Stream)
ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) Inherited from Stream
ReadByte() ReadByte() ReadByte() 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. Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

(Inherited from Stream)
Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin)

Löst eine NotSupportedException aus. Throws a NotSupportedException.

SetLength(Int64) SetLength(Int64) SetLength(Int64) SetLength(Int64)

Legt die Länge des zugrunde liegenden Streams fest. Sets the length of the underlying stream.

ShutdownAsync() ShutdownAsync() ShutdownAsync() ShutdownAsync()

Fährt diesen SslStream herunter. Shuts down this SslStream.

ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. Returns a string that represents the current object.

(Inherited from Object)
Write(Byte[]) Write(Byte[]) Write(Byte[]) Write(Byte[])

Schreibt die angegebenen Daten in diesen Stream. Writes the specified data to this stream.

Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) 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 the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Inherited from Stream
WriteAsync(Byte[], Int32, Int32) WriteAsync(Byte[], Int32, Int32) WriteAsync(Byte[], Int32, Int32) 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. Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Inherited from Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken) WriteAsync(Byte[], Int32, Int32, CancellationToken) WriteAsync(Byte[], Int32, Int32, CancellationToken) WriteAsync(Byte[], Int32, Int32, CancellationToken)

Schreibt eine Folge von Bytes asynchron in den aktuellen Stream, erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

(Inherited from Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) Inherited from Stream
WriteByte(Byte) WriteByte(Byte) WriteByte(Byte) WriteByte(Byte)

Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte. Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Inherited from Stream)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() Inherited from Stream

Gilt für:

Siehe auch