SslStream Třída

Definice

Obor názvů:

System.Net.Security

Sestavení:

System.Net.Security.dll

Zdroj:

SslStream.cs

Poskytuje datový proud používaný pro komunikaci mezi klientem a serverem, který používá protokol zabezpečení SSL (Secure Socket Layer) k ověření serveru a volitelně klienta.

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

public class SslStream : System.Net.Security.AuthenticatedStream

type SslStream = class
    inherit AuthenticatedStream

Public Class SslStream
Inherits AuthenticatedStream

Dědičnost

Object

MarshalByRefObject

Stream

AuthenticatedStream

SslStream

Příklady

Následující příklad kódu ukazuje vytvoření TcpListener, který používá třídu SslStream ke komunikaci s klienty.

#using <System.dll>

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

public:

   // The certificate parameter specifies the name of the file 
   // containing the machine certificate.
   static void RunServer( String^ certificate )
   {
      serverCertificate = X509Certificate::CreateFromCertFile( certificate );
      
      // Create a TCP/IP (IPv4) socket and listen for incoming connections.
      TcpListener^ listener = gcnew TcpListener( IPAddress::Any,5000 );
      listener->Start();
      
      while (true) 
      {
         Console::WriteLine( L"Waiting for a client to connect..." );
         
         // Application blocks while waiting for an incoming connection.
         // Type CNTL-C to terminate the server.
         TcpClient^ client = listener->AcceptTcpClient();
         ProcessClient( client );

      }
   }


   static void ProcessClient( TcpClient^ client )
   {
      
      // A client has connected. Create the 
      // SslStream using the client's network stream.
      SslStream^ sslStream = gcnew SslStream( client->GetStream(),false );
      
      // Authenticate the server but don't require the client to authenticate.
      try
      {
         sslStream->AuthenticateAsServer( serverCertificate, false, true );
         // false == no client cert required; true == check cert revocation.
         
         // Display the properties and settings for the authenticated stream.
         DisplaySecurityLevel( sslStream );
         DisplaySecurityServices( sslStream );
         DisplayCertificateInformation( sslStream );
         DisplayStreamProperties( sslStream );
         
         // Set timeouts for the read and write to 5 seconds.
         sslStream->ReadTimeout = 5000;
         sslStream->WriteTimeout = 5000;
         
         // Read a message from the client.   
         Console::WriteLine( L"Waiting for client message..." );
         String^ messageData = ReadMessage( sslStream );
         Console::WriteLine( L"Received: {0}", messageData );
         
         // Write a message to the client.
         array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the server.<EOF>" );
         Console::WriteLine( L"Sending hello message." );
         sslStream->Write( message );
      }
      catch ( AuthenticationException^ e ) 
      {
         Console::WriteLine( L"Exception: {0}", e->Message );
         if ( e->InnerException != nullptr )
         {
            Console::WriteLine( L"Inner exception: {0}", e->InnerException->Message );
         }
         Console::WriteLine( L"Authentication failed - closing the connection." );
         sslStream->Close();
         client->Close();
         return;
      }
      finally
      {
         
         // The client stream will be closed with the sslStream
         // because we specified this behavior when creating
         // the sslStream.
         sslStream->Close();
         client->Close();
      }

   }


   static String^ ReadMessage( SslStream^ sslStream )
   {
      
      // Read the  message sent by the client.
      // The client signals the end of the message using the
      // "<EOF>" marker.
      array<Byte>^buffer = gcnew array<Byte>(2048);
      StringBuilder^ messageData = gcnew StringBuilder;
      int bytes = -1;
      do
      {
         
         // Read the client's test message.
         bytes = sslStream->Read( buffer, 0, buffer->Length );
         
         // Use Decoder class to convert from bytes to UTF8
         // in case a character spans two buffers.
         Decoder^ decoder = Encoding::UTF8->GetDecoder();
         array<Char>^chars = gcnew array<Char>(decoder->GetCharCount( buffer, 0, bytes ));
         decoder->GetChars( buffer, 0, bytes, chars, 0 );
         messageData->Append( chars );
         
         // Check for EOF or an empty message.
         if ( messageData->ToString()->IndexOf( L"<EOF>" ) != -1 )
         {
            break;
         }
      }
      while ( bytes != 0 );

      return messageData->ToString();
   }


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


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


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


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

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


private:

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

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

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

};

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

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

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

                // Display the properties and settings for the authenticated stream.
                DisplaySecurityLevel(sslStream);
                DisplaySecurityServices(sslStream);
                DisplayCertificateInformation(sslStream);
                DisplayStreamProperties(sslStream);

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

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

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

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

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

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

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

        ' The certificate parameter specifies the name of the file 
        ' containing the machine certificate.
        Public Shared Sub RunServer(certificate As String)
            serverCertificate = X509Certificate.CreateFromCertFile(certificate)
            ' Create a TCP/IP (IPv4) socket And listen for incoming connections.
            Dim listener = New TcpListener(IPAddress.Any, 5000)
            listener.Start()

            While True
                Console.WriteLine("Waiting for a client to connect...")
                ' Application blocks while waiting for an incoming connection.
                ' Type CNTL-C to terminate the server.
                Dim client As TcpClient = listener.AcceptTcpClient()
                ProcessClient(client)
            End While
        End Sub
        Private Shared Sub ProcessClient(client As TcpClient)
            ' A client has connected. Create the 
            ' SslStream using the client's network stream.
            Dim sslStream = New SslStream(client.GetStream(), False)

            Try

                sslStream.AuthenticateAsServer(serverCertificate, clientCertificateRequired:=False, checkCertificateRevocation:=True)
                ' Display the properties And settings for the authenticated stream.
                DisplaySecurityLevel(sslStream)
                DisplaySecurityServices(sslStream)
                DisplayCertificateInformation(sslStream)
                DisplayStreamProperties(sslStream)

                ' Set timeouts for the read and write to 5 seconds.
                sslStream.ReadTimeout = 5000
                sslStream.WriteTimeout = 5000

                ' Read a message from the client.   
                Console.WriteLine("Waiting for client message...")
                Dim messageData As String = ReadMessage(sslStream)
                Console.WriteLine("Received: {0}", messageData)

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

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

                Console.WriteLine("Authentication failed - closing the connection.")
                sslStream.Close()
                client.Close()
                Return
            Finally
                ' The client stream will be closed with the sslStream
                ' because we specified this behavior when creating
                ' the sslStream.
                sslStream.Close()
                client.Close()
            End Try
        End Sub

        Private Shared Function ReadMessage(sslStream As SslStream) As String

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

            Do
                ' Read the client's test message.
                bytes = sslStream.Read(buffer, 0, buffer.Length)

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

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

            Return messageData.ToString()
        End Function

        Private Shared Sub DisplaySecurityLevel(stream As SslStream)
            Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength)
            Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength)
            Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength)
            Console.WriteLine("Protocol: {0}", stream.SslProtocol)
        End Sub

        Private Shared Sub DisplaySecurityServices(stream As SslStream)
            Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer)
            Console.WriteLine("IsSigned: {0}", stream.IsSigned)
            Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted)
            Console.WriteLine("Is mutually authenticated: {0}", stream.IsMutuallyAuthenticated)
        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

Následující příklad kódu ukazuje vytvoření TcpClient, který používá třídu SslStream ke komunikaci se serverem.

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

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

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

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

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

            return description;
        }

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

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

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

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

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

            int bytes = -1;
            do
            {
                bytes = sslStream->Read(buffer, 0, buffer->Length);
                 
                array<__wchar_t>^ chars = gcnew array<__wchar_t>(
                    decoder->GetCharCount(buffer, 0, bytes));
                decoder->GetChars(buffer, 0, bytes, chars, 0);
                messageData->Append(chars);
                 
                // Check for EOF.
                if (messageData->ToString()->IndexOf("<EOF>") != -1)
                {
                    break;
                }
            }
            while (bytes != 0);

            return messageData->ToString();
        }
    };
}

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

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

    return 0;
}

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

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

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

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

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

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

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

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

Namespace Examples.System.Net

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

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

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

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

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

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

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

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

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

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

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

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

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

            Return messageData.ToString()

        End Function

        Private Shared Sub DisplayUsage()

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

        End Sub

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

            Dim serverCertificateName As String
            Dim machineName As String

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

            ' User can specify the machine name and server name.
            ' Server name must match the name on the server's certificate. 
            machineName = args(0)

            If args.Length < 2 Then
                serverCertificateName = machineName
            Else
                serverCertificateName = args(1)
            End If

            SslTcpClient.RunClient(machineName, serverCertificateName)

            Return 0

        End Function

    End Class

End Namespace

Poznámky

Protokoly SSL pomáhají poskytovat důvěrnost a kontrolu integrity zpráv přenášených pomocí SslStream. Při komunikaci citlivých informací mezi klientem a serverem by se mělo použít připojení SSL, jako je například připojení poskytované SslStream. Použití SslStream pomáhá zabránit komukoli v čtení a manipulaci s informacemi, když je přenášen v síti.

Instance SslStream přenáší data pomocí datového proudu, který zadáte při vytváření SslStream. Když zadáte tento podkladový datový proud, máte možnost určit, zda zavření SslStream také zavře podkladový datový proud. Obvykle se SslStream třída používá s třídami TcpClient a TcpListener. Metoda GetStream poskytuje NetworkStream vhodné pro použití s SslStream třídou.

Po vytvoření SslStream, server a volitelně musí být klient ověřen. Server musí poskytnout certifikát X509, který vytvoří doklad o své identitě a může požádat o to, aby to klient také udělal. Před přenosem informací pomocí SslStreammusí být provedeno ověřování . Klienti zahájí ověřování pomocí synchronních metod AuthenticateAsClient, které blokují, dokud se ověřování nedokončí, nebo asynchronní metody BeginAuthenticateAsClient, které neblokují čekání na dokončení ověřování. Servery iniciují ověřování pomocí synchronních AuthenticateAsServer nebo asynchronních metod BeginAuthenticateAsServer. Klient i server musí zahájit ověřování.

Ověřování zpracovává poskytovatel kanálu SSPI (Security Support Provider). Klient má možnost řídit ověření certifikátu serveru zadáním RemoteCertificateValidationCallback delegáta při vytváření SslStream. Server může také řídit ověření zadáním RemoteCertificateValidationCallback delegáta. Metoda odkazovaná delegátem zahrnuje certifikát vzdálené strany a všechny chyby SSPI, ke kterým došlo při ověřování certifikátu. Všimněte si, že pokud server určuje delegáta, je vyvolána metoda delegáta bez ohledu na to, zda server požadoval ověření klienta. Pokud server nepožadoval ověření klienta, metoda delegáta serveru obdrží certifikát null a prázdné pole chyb certifikátu.

Pokud server vyžaduje ověření klienta, musí klient zadat jeden nebo více certifikátů pro ověření. Pokud má klient více než jeden certifikát, může klient poskytnout LocalCertificateSelectionCallback delegáta, který vybere správný certifikát pro server. Certifikáty klienta musí být umístěny v úložišti certifikátů "My" aktuálního uživatele. Ověřování klientů prostřednictvím certifikátů není podporováno pro protokol Ssl2 (SSL verze 2).

Pokud ověřování selže, obdržíte AuthenticationExceptiona SslStream se už nedá použít. Tento objekt byste měli zavřít a odebrat všechny odkazy na něj, aby ho mohl shromáždit systém uvolňování paměti.

Když se proces ověřování, označovaný také jako handshake PROTOKOLU SSL, úspěšně vytvoří identita serveru (a volitelně i klient) a SslStream může klient a server použít k výměně zpráv. Před odesláním nebo příjmem informací by měl klient a server zkontrolovat služby zabezpečení a úrovně poskytované SslStream a určit, jestli vybraný protokol, algoritmy a silné stránky splňují jejich požadavky na integritu a důvěrnost. Pokud aktuální nastavení nestačí, stream by se měl zavřít. Služby zabezpečení poskytované SslStream můžete zkontrolovat pomocí vlastností IsEncrypted a IsSigned. Následující tabulka ukazuje prvky, které hlásí kryptografické nastavení používané pro ověřování, šifrování a podepisování dat.

Element	Členové
Protokol zabezpečení používaný k ověření serveru a volitelně i klienta.	Vlastnost SslProtocol a přidružená SslProtocols výčtu.
Algoritmus výměny klíčů.	Vlastnost KeyExchangeAlgorithm a přidružená ExchangeAlgorithmType výčtu.
Algoritmus integrity zpráv.	Vlastnost HashAlgorithm a přidružená HashAlgorithmType výčtu.
Algoritmus důvěrnosti zpráv.	Vlastnost CipherAlgorithm a přidružená CipherAlgorithmType výčtu.
Silné stránky vybraných algoritmů.	Vlastnosti KeyExchangeStrength, HashStrengtha CipherStrength.

Po úspěšném ověření můžete odesílat data pomocí synchronních Write nebo asynchronních metod BeginWrite. Data můžete přijímat pomocí synchronních Read nebo asynchronních metod BeginRead.

Pokud jste zadali SslStream, že by měl být podkladový datový proud otevřený, zodpovídáte za zavření datového proudu, když ho použijete.

Poznámka

Pokud aplikace, která vytvoří objekt SslStream, běží s přihlašovacími údaji normálního uživatele, aplikace nebude mít přístup k certifikátům nainstalovaným v úložišti místního počítače, pokud mu k tomu nebyla explicitně udělena oprávnění.

SslStream předpokládá, že časový limit spolu s jinými IOException, když je vyvolán z vnitřního datového proudu, bude jeho volající považován za závažnou. Opětovné využití instance SslStream po vypršení časového limitu vrátí uvolnění paměti. Aplikace by měla CloseSslStream a v těchto případech vyvolat výjimku.

Rozhraní .NET Framework 4.6 obsahuje novou funkci zabezpečení, která blokuje nezabezpečené šifrovací a hashovací algoritmy pro připojení. Aplikace využívající protokol TLS/SSL prostřednictvím rozhraní API, jako jsou HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream atd. a cílení na rozhraní .NET Framework 4.6, ve výchozím nastavení získají bezpečnější chování.

Vývojáři můžou chtít toto chování vyloučit, aby zachovali interoperabilitu se stávajícími službami SSL3 nebo službami TLS w/ RC4. tento článek vysvětluje, jak upravit kód tak, aby bylo nové chování zakázané.

Rozhraní .NET Framework 4.7 přidává nová přetížení pro metody, které ověřují SslStreams, které nezadávají verzi PROTOKOLU TLS, ale místo toho použijte verzi PROTOKOLU TLS definovanou jako výchozí systém v SCHANNEL. Tyto metody můžete v aplikaci použít jako způsob, jak později upravit výchozí hodnoty jako osvědčené postupy při změně verze protokolu TLS v průběhu času, aniž byste museli aplikaci znovu sestavit a znovu nasadit.

Projděte si také osvědčené postupy TLS (Transport Layer Security) s rozhraním .NET Framework.

Konstruktory

SslStream(Stream)	Inicializuje novou instanci třídy SslStream pomocí zadané Stream.
SslStream(Stream, Boolean)	Inicializuje novou instanci třídy SslStream pomocí zadaného Stream a chování uzavření datového proudu.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback)	Inicializuje novou instanci třídy SslStream pomocí zadaného Stream, chování při uzavření datového proudu a delegát ověření certifikátu.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)	Inicializuje novou instanci třídy SslStream pomocí zadaného Stream, chování při uzavření datového proudu, delegát ověření certifikátu a delegát výběru certifikátu.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)	Inicializuje novou instanci třídy SslStream pomocí zadané Stream.

Vlastnosti

CanRead	Získá Boolean hodnotu, která označuje, zda je podkladový datový proud čitelný.
CanSeek	Získá Boolean hodnotu, která označuje, zda je podkladový datový proud vyhledatelný.
CanTimeout	Získá Boolean hodnotu, která označuje, zda podkladový datový proud podporuje vypršení časového limitu.
CanWrite	Získá Boolean hodnotu, která označuje, zda je podkladový datový proud zapisovatelný.
CheckCertRevocationStatus	Získá Boolean hodnotu, která označuje, zda je seznam odvolaných certifikátů kontrolován během procesu ověření certifikátu.
CipherAlgorithm	Získá hodnotu, která identifikuje algoritmus hromadného šifrování používaný tímto SslStream.
CipherStrength	Získá hodnotu, která identifikuje sílu šifrovacího algoritmu používaného tímto SslStream.
HashAlgorithm	Získá algoritmus používaný pro generování kódů ověřování zpráv (MAC).
HashStrength	Získá hodnotu, která identifikuje sílu hash algoritmu používaného touto instancí.
InnerStream	Získá datový proud používaný tímto AuthenticatedStream pro odesílání a příjem dat. (Zděděno od AuthenticatedStream)
IsAuthenticated	Získá Boolean hodnotu, která označuje, zda ověřování bylo úspěšné.
IsEncrypted	Získá Boolean hodnotu, která označuje, zda tato SslStream používá šifrování dat.
IsMutuallyAuthenticated	Získá Boolean hodnotu, která označuje, zda byl server i klient ověřen.
IsServer	Získá Boolean hodnotu, která označuje, zda místní strana připojení používaná tímto SslStream byla ověřena jako server.
IsSigned	Získá Boolean hodnotu, která označuje, zda jsou data odesílaná pomocí tohoto datového proudu podepsána.
KeyExchangeAlgorithm	Získá algoritmus výměny klíčů používaný tímto SslStream.
KeyExchangeStrength	Získá hodnotu, která identifikuje sílu algoritmu výměny klíčů používaný touto instancí.
LeaveInnerStreamOpen	Získá, zda datový proud používaný tímto AuthenticatedStream pro odesílání a příjem dat byl ponechán otevřený. (Zděděno od AuthenticatedStream)
Length	Získá délku podkladového datového proudu.
LocalCertificate	Získá certifikát použitý k ověření místního koncového bodu.
NegotiatedApplicationProtocol	Protokol vyjednané aplikace v protokolu TLS handshake.
NegotiatedCipherSuite	Získá šifrovací sadu, která byla vyjednávána pro toto připojení.
Position	Získá nebo nastaví aktuální pozici v podkladovém datovém proudu.
ReadTimeout	Získá nebo nastaví dobu vyjádřenou v milisekundách, bloky operace čtení čekající na data.
RemoteCertificate	Získá certifikát použitý k ověření vzdáleného koncového bodu.
SslProtocol	Získá hodnotu, která označuje protokol zabezpečení použitý k ověření tohoto připojení.
TargetHostName	Získá název serveru, ke kterému se klient pokouší připojit. Tento název se používá k ověření certifikátu serveru. Může to být název DNS nebo IP adresa.
TransportContext	Získá TransportContext používané pro ověřování pomocí rozšířené ochrany.
WriteTimeout	Získá nebo nastaví dobu, po kterou operace zápisu blokuje čekání na data.

Metody

AuthenticateAsClient(SslClientAuthenticationOptions)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server.
AuthenticateAsClient(String)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server.
AuthenticateAsClient(String, X509CertificateCollection, Boolean)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server. Proces ověřování používá zadanou kolekci certifikátů a výchozí protokol SSL systému.
AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server. Proces ověřování používá zadanou kolekci certifikátů a protokol SSL.
AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operaci. Proces ověřování používá informace zadané v kontejneru vlastností sslClientAuthenticationOptions.
AuthenticateAsClientAsync(String)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operaci.
AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operaci. Proces ověřování používá zadanou kolekci certifikátů a výchozí protokol SSL systému.
AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operaci. Proces ověřování používá zadanou kolekci certifikátů a protokol SSL.
AuthenticateAsServer(SslServerAuthenticationOptions)	Volal servery pro ověření serveru a volitelně klienta v připojení klienta-server pomocí zadaného certifikátu.
AuthenticateAsServer(X509Certificate)	Volal servery pro ověření serveru a volitelně klienta v připojení klienta-server pomocí zadaného certifikátu.
AuthenticateAsServer(X509Certificate, Boolean, Boolean)	Volali servery pro ověření serveru a volitelně klienta v připojení klienta-server pomocí zadaných certifikátů a požadavků a pomocí výchozího systémového protokolu zabezpečení.
AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)	Volal servery pro ověření serveru a volitelně klienta v připojení klienta-server pomocí zadaných certifikátů, požadavků a protokolu zabezpečení.
AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken)	Volal servery pro ověření serveru a volitelně klienta v připojení klient-server jako asynchronní operace. Proces ověřování používá informace vrácené optionsCallback.
AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)	Volal servery pro ověření serveru a volitelně klienta v připojení klient-server jako asynchronní operace. Proces ověřování používá informace zadané v kontejneru vlastností sslClientAuthenticationOptions.
AuthenticateAsServerAsync(X509Certificate)	Volali servery pro ověření serveru a volitelně klienta v připojení klient-server pomocí zadaného certifikátu jako asynchronní operace.
AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)	Volal servery pro ověření serveru a volitelně klienta v připojení klient-server pomocí zadaných certifikátů, požadavků a protokolu zabezpečení jako asynchronní operace.
AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)	Volal servery pro ověření serveru a volitelně klienta v připojení klient-server pomocí zadaných certifikátů, požadavků a protokolu zabezpečení jako asynchronní operace.
BeginAuthenticateAsClient(String, AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření serveru a volitelně klienta.
BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření serveru a volitelně klienta pomocí zadaných certifikátů a výchozího systémového protokolu zabezpečení.
BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření serveru a volitelně klienta pomocí zadaných certifikátů a protokolu zabezpečení.
BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)	Volá se servery, aby zahájily asynchronní operaci pro ověření klienta a volitelně i serveru v připojení klienta-server.
BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)	Volá se servery, aby zahájily asynchronní operaci pro ověření serveru a volitelně klienta pomocí zadaných certifikátů a požadavků a výchozího systémového protokolu zabezpečení.
BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)	Volají servery, aby zahájily asynchronní operaci pro ověření serveru a volitelně klienta pomocí zadaných certifikátů, požadavků a protokolu zabezpečení.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci čtení, která čte data z datového proudu a uloží je do zadaného pole.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci zápisu, která zapisuje Bytes ze zadané vyrovnávací paměti do datového proudu.
Close()	Zavře aktuální datový proud a uvolní všechny prostředky (například sokety a popisovače souborů) přidružené k aktuálnímu datovému proudu. Místo volání této metody se ujistěte, že je datový proud správně uvolněn. (Zděděno od Stream)
CopyTo(Stream)	Přečte bajty z aktuálního datového proudu a zapíše je do jiného datového proudu. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyTo(Stream, Int32)	Načte bajty z aktuálního datového proudu a zapíše je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadaného tokenu zrušení. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, Int32)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti a tokenu zrušení. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy serveru sloužícího ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
CreateWaitHandle()	Zastaralé. Přidělí objekt WaitHandle. (Zděděno od Stream)
Dispose()	Uvolní všechny prostředky používané Stream. (Zděděno od Stream)
Dispose(Boolean)	Uvolní nespravované prostředky používané SslStream a volitelně uvolní spravované prostředky.
DisposeAsync()	Asynchronně uvolní nespravované a spravované prostředky používané SslStream.
EndAuthenticateAsClient(IAsyncResult)	Ukončí čekající asynchronní operaci ověřování serveru spuštěnou s předchozím voláním BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Ukončí čekající asynchronní operaci ověřování klienta spuštěnou s předchozím voláním BeginAuthenticateAsClient.
EndRead(IAsyncResult)	Ukončí asynchronní operaci čtení spuštěnou s předchozím voláním BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Ukončí asynchronní operaci zápisu spuštěnou s předchozím voláním BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
Finalize()	Uvolní všechny prostředky používané SslStream.
Flush()	Způsobí zápis všech dat uložených do vyrovnávací paměti do podkladového zařízení.
FlushAsync()	Asynchronně vymaže všechny vyrovnávací paměti pro tento datový proud a způsobí zápis všech dat uložených do vyrovnávací paměti do podkladového zařízení. (Zděděno od Stream)
FlushAsync(CancellationToken)	Asynchronně zapíše veškerá data uložená do vyrovnávací paměti do podkladového zařízení.
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti pro řízení zásad životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního objektu MarshalByRefObject. (Zděděno od MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)	Vyjedná klientský certifikát u ověřeného připojení.
ObjectInvariant()	Zastaralé. Poskytuje podporu pro Contract. (Zděděno od Stream)
Read(Byte[], Int32, Int32)	Načte data z tohoto datového proudu a uloží je do zadaného pole.
Read(Span<Byte>)	Při přepsání v odvozené třídě přečte posloupnost bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAsync(Byte[], Int32, Int32)	Asynchronně čte posloupnost bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně čte data z tohoto datového proudu a ukládá je v zadaném rozsahu bajtového pole.
ReadAsync(Memory<Byte>, CancellationToken)	Asynchronně čte data z tohoto datového proudu a ukládá je do zadaného rozsahu paměti.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Čte alespoň minimální počet bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Asynchronně čte alespoň minimální počet bajtů z aktuálního datového proudu, posune pozici v rámci datového proudu o počet přečtených bajtů a monitoruje žádosti o zrušení. (Zděděno od Stream)
ReadByte()	Přečte bajt z SslStream a posune pozici v datovém proudu o jeden bajt nebo vrátí -1, pokud je na konci datového proudu.
ReadExactly(Byte[], Int32, Int32)	Přečte count počet bajtů z aktuálního datového proudu a posune pozici v rámci datového proudu. (Zděděno od Stream)
ReadExactly(Span<Byte>)	Přečte bajty z aktuálního datového proudu a posune pozici v rámci datového proudu, dokud se buffer nenaplní. (Zděděno od Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně čte count počet bajtů z aktuálního datového proudu, posune pozici v rámci datového proudu a monitoruje požadavky na zrušení. (Zděděno od Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu, posune pozici v rámci datového proudu, dokud se buffer nenaplní, a monitoruje žádosti o zrušení. (Zděděno od Stream)
Seek(Int64, SeekOrigin)	Vyvolá NotSupportedException.
SetLength(Int64)	Nastaví délku podkladového datového proudu.
ShutdownAsync()	Vypne tento SslStream.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
Write(Byte[])	Zapíše zadaná data do tohoto datového proudu.
Write(Byte[], Int32, Int32)	Pomocí zadané vyrovnávací paměti a posunu napište zadaný počet Bytes do podkladového datového proudu.
Write(ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě zapíše posloupnost bajtů do aktuálního datového proudu a posune aktuální pozici v tomto datovém proudu počtem zapsaných bajtů. (Zděděno od Stream)
WriteAsync(Byte[], Int32, Int32)	Asynchronně zapíše posloupnost bajtů do aktuálního datového proudu a posune aktuální pozici v tomto datovém proudu o počet zapsaných bajtů. (Zděděno od Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně zapisuje data do podkladového datového proudu ze zadané oblasti pole bajtů.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Asynchronně zapisuje data do podkladového datového proudu z rozsahu paměti jen pro čtení.
WriteByte(Byte)	Zapíše bajt na aktuální pozici v datovém proudu a posune pozici v rámci datového proudu o jeden bajt. (Zděděno od Stream)

Metody rozšíření

CopyToAsync(Stream, PipeWriter, CancellationToken)	Asynchronně čte bajty z Stream a zapisuje je do zadané PipeWriterpomocí tokenu zrušení.
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguruje, jak čekají na úlohy vrácené z asynchronního jednorázového použití.

Viz také

• NegotiateStream
• AuthenticatedStream
• IOException
• Stream