SslStream Třída

Definice

Obor názvů:

System.Net.Security

Sestavení:

System.Net.Security.dll

Sestavení:

System.dll

Sestavení:

netstandard.dll

Poskytuje stream 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

type SslStream = class
    inherit AuthenticatedStream
    interface IDisposable

Public Class SslStream
Inherits AuthenticatedStream

Dědičnost

Object

Stream

AuthenticatedStream

SslStream

Dědičnost

Object

MarshalByRefObject

Stream

AuthenticatedStream

SslStream

Implementuje

IDisposable

Příklady

Následující příklad kódu ukazuje vytvoření TcpListener třídy, která používá SslStream třídu 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,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

Následující příklad kódu ukazuje vytvoření TcpClient třídy, která používá SslStream třídu 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, 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

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 takové, které SslStreamposkytuje. SslStream Použití funkce pomáhá zabránit tomu, aby kdokoli četl a manipuluje s informacemi během přenosu 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, jestli se zavření SslStream také podkladového datového proudu zavře. SslStream Třída se obvykle používá s třídami TcpClient a TcpListener třídami. Metoda GetStream poskytuje NetworkStream vhodný pro použití s SslStream třídou.

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

Ověřování zpracovává poskytovatel kanálu SSPI (Security Support Provider). Klientovi je udělena příležitost řídit ověření certifikátu serveru zadáním delegáta RemoteCertificateValidationCallback při vytváření SslStream. Server může také řídit ověření zadáním delegáta RemoteCertificateValidationCallback . Metoda odkazovaná delegátem zahrnuje certifikát vzdálené strany a případné chyby SSPI při ověřování certifikátu. Všimněte si, že pokud server určuje delegáta, metoda delegáta se vyvolá bez ohledu na to, jestli 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ěřování. Pokud má klient více certifikátů, může klient poskytnout delegáta LocalCertificateSelectionCallback , který vybere správný certifikát pro server. Certifikáty klienta musí být umístěné 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 Ssl2 protokol (SSL verze 2).

Pokud se ověření nezdaří, obdržíte a AuthenticationExceptionuž není možné ho SslStream použít. Tento objekt byste měli zavřít a odebrat všechny odkazy na něj, aby bylo možné ho shromáždit uvolňováním paměti.

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

Prvek	Členové
Protokol zabezpečení používaný k ověření serveru a případně klienta.	Vlastnost SslProtocol a přidružený SslProtocols výčet.
Algoritmus výměny klíčů.	Vlastnost KeyExchangeAlgorithm a přidružený ExchangeAlgorithmType výčet.
Algoritmus integrity zpráv.	Vlastnost HashAlgorithm a přidružený HashAlgorithmType výčet.
Algoritmus důvěrnosti zpráv.	Vlastnost CipherAlgorithm a přidružený CipherAlgorithmType výčet.
Síla vybraných algoritmů.	The KeyExchangeStrength, HashStrengthand CipherStrength properties.

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

Pokud jste zadali SslStream , že podkladový datový proud by měl zůstat otevřený, zodpovídáte za zavření daného datového proudu, až ho použijete.

Poznámka

Pokud aplikace, která vytvoří SslStream objekt, 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 místním úložišti počítačů, pokud mu není výslovně uděleno oprávnění k tomu.

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

.NET Framework 4.6 obsahuje novou funkci zabezpečení, která blokuje nezabezpečené šifrovací algoritmy a algoritmy hash pro připojení. Aplikace používající protokol TLS/SSL prostřednictvím rozhraní API, jako jsou HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream atd. a cílení na .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 svými 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é.

.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žívají verzi PROTOKOLU TLS definovanou jako výchozí systém v SCHANNEL. Tyto metody v aplikaci použijte jako způsob, jak později změnit výchozí hodnoty jako osvědčené postupy pro verzi PROTOKOLU TLS v průběhu času, aniž byste museli aplikaci znovu znovu sestavit a nasadit.

Podívejte se také na osvědčené postupy protokolu TLS (Transport Layer Security) s .NET Framework.

Konstruktory

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

Vlastnosti

CanRead	Boolean Získá hodnotu, která označuje, zda je podkladový datový proud čitelný.
CanSeek	Boolean Získá hodnotu, která označuje, zda je podkladový datový proud vyhledatelný.
CanTimeout	Boolean Získá hodnotu, která označuje, zda podkladový datový proud podporuje vypršení časového limitu.
CanWrite	Boolean Získá hodnotu, která označuje, zda je podkladový datový proud zapisovatelný.
CheckCertRevocationStatus	Boolean Získá 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žitý 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 způsobem pro odesílání a příjem dat. (Zděděno od AuthenticatedStream)
IsAuthenticated	Boolean Získá hodnotu, která označuje, zda ověřování bylo úspěšné.
IsEncrypted	Boolean Získá hodnotu, která označuje, zda se používá SslStream šifrování dat.
IsMutuallyAuthenticated	Boolean Získá hodnotu, která označuje, zda byl server i klient ověřen.
IsServer	Boolean Získá hodnotu, která označuje, zda místní strana připojení používaná tímto SslStream způsobem byla ověřena jako server.
IsSigned	Boolean Získá hodnotu, která označuje, zda jsou data odeslaná 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 způsobem 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	Vyjednaný aplikační protokol v handshake protokolu TLS.
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 streamu.
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á pro ověření certifikátu serveru. Může to být název DNS nebo IP adresa.
TransportContext	TransportContext Získá použití 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 k ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operace. Proces ověřování používá informace zadané v taškě sslClientAuthenticationOptions vlastností.
AuthenticateAsClientAsync(String)	Volali klienti k ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operace.
AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)	Volali klienti k ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operace. Proces ověřování používá zadanou kolekci certifikátů a výchozí protokol SSL systému.
AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)	Volali klienti k ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operace. Proces ověřování používá zadanou kolekci certifikátů a protokol SSL.
AuthenticateAsServer(SslServerAuthenticationOptions)	Volali servery pro ověření serveru a volitelně klienta v připojení klientského serveru pomocí zadaného certifikátu.
AuthenticateAsServer(X509Certificate)	Volali servery pro ověření serveru a volitelně klienta v připojení klientského serveru pomocí zadaného certifikátu.
AuthenticateAsServer(X509Certificate, Boolean, Boolean)	Volali servery pro ověření serveru a volitelně klienta v připojení klientského serveru pomocí zadaných certifikátů a požadavků a pomocí výchozího systémového protokolu zabezpečení.
AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)	Volali servery pro ověření serveru a volitelně klienta v připojení k klientskému serveru pomocí zadaných certifikátů, požadavků a protokolu zabezpečení.
AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken)	Volá se servery k ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operace. Proces ověřování používá informace vrácené optionsCallback.
AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)	Volá se servery k ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operace. Proces ověřování používá informace zadané v taškě sslClientAuthenticationOptions vlastností.
AuthenticateAsServerAsync(X509Certificate)	Volali servery k ověření serveru a volitelně klienta v připojení klientského serveru pomocí zadaného certifikátu jako asynchronní operace.
AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)	Volali servery pro ověření serveru a volitelně klienta v připojení k klientskému serveru pomocí zadaných certifikátů, požadavků a protokolu zabezpečení jako asynchronní operace.
AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)	Volali servery pro ověření serveru a volitelně klienta v připojení k klientskému serveru 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 protokolu zabezpečení systému.
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ě serveru v připojení klienta-server.
BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)	Volá se servery pro zahájení asynchronní operace 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)	Spustí asynchronní operaci čtení, která čte data ze streamu a uloží je do zadaného pole.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci čtení. (Zvažte místo toho ReadAsync(Byte[], Int32, Int32) použití .) (Zděděno od Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Začíná asynchronní operace zápisu, která zapisuje Bytez zadané vyrovnávací paměti do datového proudu.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci zápisu. (Zvažte místo toho WriteAsync(Byte[], Int32, Int32) použití .) (Zděděno od Stream)
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ě odstraně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. (Zděděno od Stream)
CopyTo(Stream, Int32)	Přeč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. (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. (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í. (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. (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í. (Zděděno od Stream)
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy serveru používaného ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
CreateWaitHandle()	Zastaralé. Zastaralé. Přidělí WaitHandle objekt . (Zděděno od Stream)
Dispose()	Uvolní všechny prostředky používané v Stream . (Zděděno od Stream)
Dispose(Boolean)	Uvolní nespravované prostředky používané SslStream a volitelně uvolní spravované prostředky.
Dispose(Boolean)	Uvolní nespravované prostředky používané AuthenticatedStream a volitelně uvolní spravované prostředky. (Zděděno od AuthenticatedStream)
DisposeAsync()	Asynchronně uvolní nespravované a spravované prostředky používané nástrojem SslStream.
DisposeAsync()	Asynchronně uvolní nespravované a spravované prostředky používané nástrojem AuthenticatedStream. (Zděděno od AuthenticatedStream)
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).
EndRead(IAsyncResult)	Čeká na dokončení čekajícího asynchronního čtení. (Zvažte místo toho ReadAsync(Byte[], Int32, Int32) použití .) (Zděděno od Stream)
EndWrite(IAsyncResult)	Ukončí asynchronní operaci zápisu spuštěnou s předchozím voláním BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Ukončí asynchronní operaci zápisu. (Zvažte místo toho WriteAsync(Byte[], Int32, Int32) použití .) (Zděděno od Stream)
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
Finalize()	Uvolní všechny prostředky používané nástrojem 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 ve vyrovnávací paměti do základního zařízení. (Zděděno od Stream)
FlushAsync(CancellationToken)	Asynchronně zapisuje všechna data uložená do vyrovnávací paměti do podkladového zařízení.
FlushAsync(CancellationToken)	Asynchronně vymaže všechny vyrovnávací paměti pro tento datový proud, způsobí zápis všech dat ve vyrovnávací paměti do základního zařízení a monitoruje žádosti o zrušení. (Zděděno od Stream)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte aktuální objekt služby životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Type Získá aktuální instanci. (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ří použádnou kopii aktuálního souboru Object. (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří kopii aktuálního objektu bez MarshalByRefObject podmět. (Zděděno od MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)	Vyjedná klientský certifikát na ověřeném 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 sekvence bajtů z aktuálního datového proudu a posune pozici v rámci datového proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAsync(Byte[], Int32, Int32)	Asynchronně přečte sekvenci bajtů z aktuálního datového proudu a posune pozici v rámci datového 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 do zadané oblasti bajtového pole.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně přečte sekvenci 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 požadavky zrušení. (Zděděno od Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Asynchronně čte data z tohoto datového proudu a ukládá je do zadaného rozsahu paměti.
ReadAsync(Memory<Byte>, CancellationToken)	Asynchronně přečte sekvenci 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 požadavky zrušení. (Zděděno od Stream)
ReadByte()	Přečte bajt z SslStream datového proudu a posune pozici v rámci datového proudu o jeden bajt nebo vrátí hodnotu -1, pokud je na konci datového proudu.
ReadByte()	Přečte z datového proudu bajtů a posune pozici v rámci datového proudu o jeden bajtů, nebo vrátí hodnotu -1, pokud je na konci datového proudu. (Zděděno od Stream)
Seek(Int64, SeekOrigin)	Vyhodí NotSupportedException.
SetLength(Int64)	Nastaví délku podkladového datového proudu.
ShutdownAsync()	Vypne tento protokol 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)	Napište zadaný počet Bytes do podkladového datového proudu pomocí zadané vyrovnávací paměti a posunu.
Write(ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě zapíše sekvenci bajtů do aktuálního datového proudu a posune aktuální pozici v rámci tohoto datového proudu o počet zapsané bajty. (Zděděno od Stream)
WriteAsync(Byte[], Int32, Int32)	Asynchronně zapíše sekvenci bajtů do aktuálního datového proudu a posune aktuální pozici v rámci tohoto datového proudu o počet zapsané bajty. (Zděděno od Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně zapisuje data do podkladového datového proudu ze zadané oblasti bajtového pole.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně zapíše sekvenci bajtů do aktuálního datového proudu, posune aktuální pozici v rámci tohoto datového proudu o počet zapsané bajty a monitoruje požadavky zrušení. (Zděděno od Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Asynchronní zápis dat do podkladového datového proudu z bajtů jen pro čtení.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Asynchronně zapíše sekvenci bajtů do aktuálního datového proudu, posune aktuální pozici v rámci tohoto datového proudu o počet zapsané bajty a monitoruje požadavky zrušení. (Zděděno od Stream)
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í

ConfigureAwait(IAsyncDisposable, Boolean)

Nakonfiguruje, jak se čekají na úlohy vrácené z asynchronního jednorázového provedení.

Viz také

• NegotiateStream
• AuthenticatedStream
• IOException
• Stream