SslStream Klasse

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
Implementiert

Beispiele

Das folgende Codebeispiel veranschaulicht das Erstellen einer TcpListener, die die SslStream-Klasse für die Kommunikation mit Clients verwendet.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;
        } 
    }
}
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, 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.
                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

Das folgende Codebeispiel veranschaulicht das Erstellen einer TcpClient, die die SslStream-Klasse für die Kommunikation mit einem Server verwendet.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;
        }
    }
}
    
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, 443)
            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 ermöglichen die Überprüfung von Vertraulichkeit und Integrität für Nachrichten, die mithilfe einer SslStreamübertragen werden.SSL protocols help to provide confidentiality and integrity checking for messages transmitted using an SslStream. Eine SSL-Verbindung, z. b. die von SslStreambereitgestellte, sollte verwendet werden, wenn sensible Informationen zwischen einem Client und einem Server kommuniziert werden.An SSL connection, such as that provided by SslStream, should be used when communicating sensitive information between a client and a server. Mithilfe einer SslStream können Sie verhindern, dass Daten während der Übertragung im Netzwerk gelesen und manipuliert werden.Using an SslStream helps to prevent anyone from reading and tampering with information while it is in transit on the network.

Eine SslStream Instanz überträgt Daten mithilfe eines Datenstroms, den Sie beim Erstellen des SslStreambereitstellen.An SslStream instance transmits data using a stream that you supply when creating the SslStream. Wenn Sie diesen zugrunde liegenden Stream bereitstellen, haben Sie die Möglichkeit anzugeben, ob durch das Schließen des SslStream auch der 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 wird die SslStream-Klasse mit den Klassen TcpClient und TcpListener verwendet.Typically, the SslStream class is used with the TcpClient and TcpListener classes. Die GetStream-Methode bietet eine NetworkStream, die für die Verwendung mit der SslStream-Klasse geeignet ist.The GetStream method provides a NetworkStream suitable for use with the SslStream class.

Nachdem Sie einen SslStream, den Server und optional den-Client erstellt haben, muss er authentifiziert werden.After creating an SslStream, the server and optionally, the client must be authenticated. Der Server muss ein x. 509-Zertifikat bereitstellen, das einen Nachweis seiner Identität festlegt und auch anfordern kann, dass der Client dies auch tun kann.The server must provide an X509 certificate that establishes proof of its identity and can request that the client also do so. Vor dem Übertragen von Informationen mithilfe eines SslStreammuss die Authentifizierung erfolgen.Authentication must be performed before transmitting information using an SslStream. Clients initiieren die Authentifizierung mithilfe der synchronen AuthenticateAsClient Methoden, die blockieren, bis die Authentifizierung abgeschlossen ist, oder der asynchronen BeginAuthenticateAsClient Methoden, die nicht blockieren, bis die Authentifizierung abgeschlossen ist.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 mithilfe des synchronen AuthenticateAsServer oder der asynchronen BeginAuthenticateAsServer Methoden.Servers initiate authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. Die Authentifizierung muss sowohl vom Client als auch vom Server initiiert werden.Both client and server must initiate the authentication.

Die Authentifizierung wird vom SSPI-Kanalanbieter (Security Support Provider) abgewickelt.The authentication is handled by the Security Support Provider (SSPI) channel provider. Der Client erhält die Möglichkeit, die Überprüfung des Serverzertifikats zu steuern, indem er beim Erstellen eines SslStreameinen RemoteCertificateValidationCallback Delegaten angibt.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 die Validierung auch steuern, indem er einen RemoteCertificateValidationCallback Delegaten bereitstellt.The server can also control validation by supplying a RemoteCertificateValidationCallback delegate. Die Methode, auf die der Delegat verweist, umfasst das Zertifikat der Remote Partei und alle Fehler SSPI bei der Überprüfung des Zertifikats.The method referenced by the delegate includes the remote party's certificate and any errors SSPI encountered while validating the certificate. Beachten Sie Folgendes: Wenn der Server einen Delegaten angibt, wird die-Methode des Delegaten unabhängig davon aufgerufen, ob der Server die Client Authentifizierung angefordert hat.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 die Client Authentifizierung nicht angefordert hat, empfängt die Delegatmethode des Servers ein NULL-Zertifikat und ein leeres Array von Zertifikat Fehlern.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 eine Client Authentifizierung erfordert, muss der Client mindestens ein Zertifikat für die Authentifizierung angeben.If the server requires client authentication, the client must specify one or more certificates for authentication. Wenn der Client über mehr als ein Zertifikat verfügt, kann der Client einen LocalCertificateSelectionCallback Delegaten bereitstellen, um das richtige Zertifikat für den Server auszuwä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 Zertifikat Speicher des aktuellen Benutzers befinden.The client's certificates must be located in the current user's "My" certificate store. Die Client Authentifizierung über Zertifikate wird für das Ssl2 (SSL Version 2)-Protokoll nicht unterstützt.Client authentication via certificates is not supported for the Ssl2 (SSL version 2) protocol.

Wenn die Authentifizierung fehlschlägt, erhalten Sie eine AuthenticationException, und der SslStream ist nicht mehr verwendbar.If the authentication fails, you receive a AuthenticationException, and the SslStream is no longer useable. Sie sollten dieses Objekt schließen und alle Verweise darauf entfernen, damit 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 der Authentifizierungsprozess, auch als SSL-Handshake bezeichnet, erfolgreich ist, wird die Identität des Servers (und optional des Clients) hergestellt, und der SslStream kann vom Client und vom Server zum Austauschen von Nachrichten verwendet werden.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 sollten der Client und der Server die vom SslStream bereitgestellten Sicherheitsdienste und-Ebenen überprüfen, um festzustellen, ob das ausgewählte Protokoll, die Algorithmen und die stärken die Anforderungen für die Integrität erfüllen und wahren.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 ausreichen, sollte der Stream geschlossen werden.If the current settings are not sufficient, the stream should be closed. Mithilfe der Eigenschaften IsEncrypted und IsSigned können Sie die vom SslStream bereitgestellten Sicherheitsdienste überprüfen.You can check the security services provided by the SslStream using the IsEncrypted and IsSigned properties. In der folgenden Tabelle sind die Elemente aufgeführt, die die für die Authentifizierung, Verschlüsselung und Daten Signierung verwendeten kryptografischen Einstellungen melden.The following table shows the elements that report the cryptographic settings used for authentication, encryption and data signing.

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

Nach einer erfolgreichen Authentifizierung können Sie Daten mithilfe der synchronen Write oder asynchronen BeginWrite Methoden senden.After a successful authentication, you can send data using the synchronous Write or asynchronous BeginWrite methods. Sie können Daten mithilfe der synchronen Read oder asynchronen BeginRead Methoden empfangen.You can receive data using the synchronous Read or asynchronous BeginRead methods.

Wenn Sie für den SslStream festgelegt haben, dass der zugrunde liegende Stream geöffnet bleiben soll, sind Sie dafür verantwortlich, diesen Stream zu schließen, wenn Sie ihn 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, die das SslStream Objekt erstellt, mit den Anmelde Informationen eines normalen Benutzers ausgeführt wird, kann die Anwendung nicht auf Zertifikate zugreifen, die im lokalen Speicher des Computers installiert sind, es sei denn, die Berechtigung wurde explizit dem Benutzer erteilt.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 geht davon aus, dass ein Timeout zusammen mit allen anderen IOException, wenn eine aus dem inneren Stream ausgelöst wird, vom Aufrufer als schwerwiegender Wert behandelt wird.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. Wenn Sie eine SslStream Instanz nach einem Timeout wieder verwenden, wird die Garbage Collection zurückgegeben.Reusing a SslStream instance after a timeout will return garbage. Eine Anwendung sollte die SslStream Close und in diesen Fällen eine Ausnahme auslösen.An application should Close the SslStream and throw an exception in these cases.

Der .NET Framework 4,6 umfasst ein neues Sicherheits Feature, das unsichere Verschlüsselungs-und Hash Algorithmen für Verbindungen blockiert.The .NET Framework 4.6 includes a new security feature that blocks insecure cipher and hashing algorithms for connections. Anwendungen, die TLS/SSL über APIs wie z. b. HttpClient, HttpWebRequest, FtpClient, SmtpClient, SslStream usw. und das Ziel .NET Framework 4,6 verwenden, erhalten standardmäßig das sicherere Verhalten.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 möchten dieses Verhalten möglicherweise ablehnen, um die Interoperabilität mit Ihren vorhandenen SSL3 Services-oder TLS-/RC4-Diensten aufrechtzuerhalten.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 den Code so ändern, dass das neue Verhalten deaktiviert ist.This article explains how to modify your code so that the new behavior is disabled.

Der .NET Framework 4,7 fügt neue über Ladungen für die Methoden hinzu, die sslstreams authentifizieren, die keine TLS-Version angeben, sondern stattdessen die als System Standard definierte TLS-Version in SChannelverwenden.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, um die Standardeinstellungen später ändern zu können, da sich die bewährte Methode der TLS-Version im Laufe der Zeit ändert, ohne die APP neu erstellen und bereitstellen zu müssen.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.

Weitere Informationen finden Sie auch unter Transport Layer Security (TLS) Best Practices mit der .NET Framework.Also see Transport Layer Security (TLS) best practices with the .NET Framework.

Konstruktoren

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)

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)

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)

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)

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

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

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

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

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

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

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

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

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

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

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.

(Geerbt von AuthenticatedStream)
IsAuthenticated

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

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

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

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

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

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

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

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.

(Geerbt von AuthenticatedStream)
Length

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

LocalCertificate

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

NegotiatedApplicationProtocol
NegotiatedCipherSuite

Ruft die Verschlüsselungssammlung ab, die für diese Verbindung ausgehandelt wurde.Gets the cipher suite which was negotiated for this connection.

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

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

RemoteCertificate

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

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

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

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)

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)

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)

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

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)

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)

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)

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 system default security protocol.

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

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.

(Geerbt von 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.

(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.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Geerbt von 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.

(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.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(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.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

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

(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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Geerbt von MarshalByRefObject)
CreateWaitHandle()

Reserviert ein WaitHandle-Objekt.Allocates a WaitHandle object.

(Geerbt von Stream)
Dispose()

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

(Geerbt von Stream)
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.

DisposeAsync()

Gibt die nicht verwalteten und verwalteten Ressourcen, die von SslStream verwendet werden, asynchron frei.Asynchronously releases the unmanaged and managed resources used by the SslStream.

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)

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)

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)

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)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
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()

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.

(Geerbt von Stream)
FlushAsync(CancellationToken)
GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
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.

(Geerbt von MarshalByRefObject)
GetType()

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

(Geerbt von Object)
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.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

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

(Geerbt von Object)
MemberwiseClone(Boolean)

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

(Geerbt von MarshalByRefObject)
ObjectInvariant()

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

(Geerbt von Stream)
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>)

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.When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(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.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Geerbt von Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Liest Daten asynchron aus diesem Datenstrom und speichert sie im angegebenen Bereich eines Bytearrays.Asynchronously reads data from this stream and stores it in the specified range of a byte array.

ReadAsync(Memory<Byte>, CancellationToken)

Liest Daten asynchron aus diesem Datenstrom und speichert sie im angegebenen Speicherbereich.Asynchronously reads data from this stream and stores it in the specified memory range.

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.Reads a byte from the SslStream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

Seek(Int64, SeekOrigin)

Löst eine NotSupportedException aus.Throws a NotSupportedException.

SetLength(Int64)

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

ShutdownAsync()

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

ToString()

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

(Geerbt von Object)
Write(Byte[])

Schreibt die angegebenen Daten in diesen Stream.Writes the specified data to this 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 the specified number of Bytes to the underlying stream using the specified buffer and offset.

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.When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(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.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Geerbt von Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Schreibt Daten aus dem festgelegten Bereich eines Bytearrays asynchron in den zugrunde liegenden Datenstrom.Asynchronously writes data to the underlying stream from the specified range of a byte array.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Schreibt Daten asynchron in den zugrunde liegenden Datenstrom eines schreibgeschützten Bytespeicherbereichs.Asynchronously writes data to the underlying stream from a read-only byte memory range.

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.

(Geerbt von Stream)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

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

(Geerbt von Stream)

Gilt für:

Siehe auch