SslStream Classe

Definição

Namespace:

System.Net.Security

Assembly:

System.Net.Security.dll

Origem:

SslStream.cs

Fornece um fluxo usado para comunicação cliente-servidor que usa o protocolo de segurança SSL (Secure Socket Layer) para autenticar o servidor e, opcionalmente, o cliente.

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

Herança

Object

MarshalByRefObject

Stream

AuthenticatedStream

SslStream

Exemplos

O exemplo de código a seguir demonstra a criação de um TcpListener que usa a classe SslStream para se comunicar com clientes.

#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

O exemplo de código a seguir demonstra a criação de um TcpClient que usa a classe SslStream para se comunicar com um servidor.

#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

Comentários

Os protocolos SSL ajudam a fornecer verificação de confidencialidade e integridade para mensagens transmitidas usando um SslStream. Uma conexão SSL, como a fornecida por SslStream, deve ser usada ao comunicar informações confidenciais entre um cliente e um servidor. O uso de um SslStream ajuda a impedir que qualquer pessoa leia e viole informações enquanto ela está em trânsito na rede.

Uma instância de SslStream transmite dados usando um fluxo que você fornece ao criar o SslStream. Ao fornecer esse fluxo subjacente, você tem a opção de especificar se o fechamento do SslStream também fecha o fluxo subjacente. Normalmente, a classe SslStream é usada com as classes TcpClient e TcpListener. O método GetStream fornece uma NetworkStream adequada para uso com a classe SslStream.

Depois de criar um SslStream, o servidor e, opcionalmente, o cliente deve ser autenticado. O servidor deve fornecer um certificado X509 que estabelece a prova de sua identidade e pode solicitar que o cliente também faça isso. A autenticação deve ser executada antes de transmitir informações usando um SslStream. Os clientes iniciam a autenticação usando os métodos de AuthenticateAsClient síncronos, que bloqueiam até que a autenticação seja concluída ou os métodos de BeginAuthenticateAsClient assíncronos, que não bloqueiam a espera da conclusão da autenticação. Os servidores iniciam a autenticação usando os métodos AuthenticateAsServer síncronos ou assíncronos BeginAuthenticateAsServer. O cliente e o servidor devem iniciar a autenticação.

A autenticação é tratada pelo provedor de canal SSPI (Provedor de Suporte de Segurança). O cliente tem a oportunidade de controlar a validação do certificado do servidor especificando um delegado RemoteCertificateValidationCallback ao criar um SslStream. O servidor também pode controlar a validação fornecendo um delegado de RemoteCertificateValidationCallback. O método referenciado pelo delegado inclui o certificado da parte remota e todos os erros que a SSPI encontrou ao validar o certificado. Observe que, se o servidor especificar um delegado, o método do delegado será invocado independentemente de a autenticação do cliente solicitada pelo servidor. Se o servidor não solicitou a autenticação do cliente, o método delegado do servidor receberá um certificado nulo e uma matriz vazia de erros de certificado.

Se o servidor exigir autenticação de cliente, o cliente deverá especificar um ou mais certificados para autenticação. Se o cliente tiver mais de um certificado, o cliente poderá fornecer um representante LocalCertificateSelectionCallback para selecionar o certificado correto para o servidor. Os certificados do cliente devem estar localizados no repositório de certificados "My" do usuário atual. Não há suporte para autenticação de cliente por meio de certificados para o protocolo Ssl2 (versão 2 do SSL).

Se a autenticação falhar, você receberá um AuthenticationExceptione o SslStream não será mais utilizável. Você deve fechar esse objeto e remover todas as referências a ele para que ele possa ser coletado pelo coletor de lixo.

Quando o processo de autenticação, também conhecido como handshake SSL, é bem-sucedido, a identidade do servidor (e, opcionalmente, o cliente) é estabelecida e o SslStream pode ser usado pelo cliente e pelo servidor para trocar mensagens. Antes de enviar ou receber informações, o cliente e o servidor devem verificar os serviços de segurança e os níveis fornecidos pelo SslStream para determinar se o protocolo, os algoritmos e os pontos fortes selecionados atendem aos requisitos de integridade e confidencialidade. Se as configurações atuais não forem suficientes, o fluxo deverá ser fechado. Você pode verificar os serviços de segurança fornecidos pelo SslStream usando as propriedades IsEncrypted e IsSigned. A tabela a seguir mostra os elementos que relatam as configurações de criptografia usadas para autenticação, criptografia e assinatura de dados.

Elemento	Membros
O protocolo de segurança usado para autenticar o servidor e, opcionalmente, o cliente.	A propriedade SslProtocol e a enumeração SslProtocols associada.
O algoritmo de troca de chaves.	A propriedade KeyExchangeAlgorithm e a enumeração ExchangeAlgorithmType associada.
O algoritmo de integridade da mensagem.	A propriedade HashAlgorithm e a enumeração HashAlgorithmType associada.
O algoritmo de confidencialidade da mensagem.	A propriedade CipherAlgorithm e a enumeração CipherAlgorithmType associada.
Os pontos fortes dos algoritmos selecionados.	As propriedades KeyExchangeStrength, HashStrengthe CipherStrength.

Após uma autenticação bem-sucedida, você pode enviar dados usando os métodos Write síncronos ou assíncronos BeginWrite. Você pode receber dados usando os métodos Read síncronos ou assíncronos BeginRead.

Se você especificou ao SslStream que o fluxo subjacente deve ser deixado aberto, você será responsável por fechar esse fluxo quando terminar de usá-lo.

Nota

Se o aplicativo que cria o objeto SslStream for executado com as credenciais de um usuário Normal, o aplicativo não poderá acessar certificados instalados no repositório de máquinas local, a menos que a permissão tenha sido explicitamente dada ao usuário para fazer isso.

SslStream pressupõe que um tempo limite junto com qualquer outro IOException quando um for lançado do fluxo interno será tratado como fatal por seu chamador. Reutilização de uma instância de SslStream após um tempo limite retornará o lixo. Um aplicativo deve Close o SslStream e gerar uma exceção nesses casos.

O .NET Framework 4.6 inclui um novo recurso de segurança que bloqueia algoritmos de criptografia e hash inseguros para conexões. Os aplicativos que usam TLS/SSL por meio de APIs como HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream etc. e direcionamento ao .NET Framework 4.6 obtêm o comportamento mais seguro por padrão.

Talvez os desenvolvedores desejem recusar esse comportamento para manter a interoperabilidade com seus serviços SSL3 ou TLS w/ RC4 existentes. Este artigo explica como modificar seu código para que o novo comportamento seja desabilitado.

O .NET Framework 4.7 adiciona novas sobrecargas para os métodos que autenticam sslStreams que não especificam uma versão do TLS, mas usam a versão do TLS definida como o padrão do sistema em SCHANNEL. Use esses métodos em seu aplicativo como uma maneira de modificar os padrões posteriormente, pois as melhores práticas de versão do TLS mudam ao longo do tempo, sem a necessidade de recriar e reimplantar seu aplicativo.

Consulte também as práticas recomendadas do TLS (Transport Layer Security) com o .NET Framework.

Construtores

SslStream(Stream)	Inicializa uma nova instância da classe SslStream usando o Streamespecificado.
SslStream(Stream, Boolean)	Inicializa uma nova instância da classe SslStream usando o comportamento de fechamento de fluxo e Stream especificado.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback)	Inicializa uma nova instância da classe SslStream usando o Streamespecificado, o comportamento de fechamento do fluxo e o delegado de validação de certificado.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)	Inicializa uma nova instância da classe SslStream usando o Streamespecificado, o comportamento de fechamento do fluxo, o delegado de validação de certificado e o delegado de seleção de certificado.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)	Inicializa uma nova instância da classe SslStream usando o Streamespecificado.

Propriedades

CanRead	Obtém um valor Boolean que indica se o fluxo subjacente é legível.
CanSeek	Obtém um valor Boolean que indica se o fluxo subjacente é procurado.
CanTimeout	Obtém um valor Boolean que indica se o fluxo subjacente dá suporte a tempos limite.
CanWrite	Obtém um valor Boolean que indica se o fluxo subjacente é gravável.
CheckCertRevocationStatus	Obtém um valor Boolean que indica se a lista de revogação de certificado é verificada durante o processo de validação do certificado.
CipherAlgorithm	Obtém um valor que identifica o algoritmo de criptografia em massa usado por esse SslStream.
CipherStrength	Obtém um valor que identifica a força do algoritmo de criptografia usado por esse SslStream.
HashAlgorithm	Obtém o algoritmo usado para gerar MACs (códigos de autenticação de mensagem).
HashStrength	Obtém um valor que identifica a força do algoritmo de hash usado por essa instância.
InnerStream	Obtém o fluxo usado por esse AuthenticatedStream para enviar e receber dados. (Herdado de AuthenticatedStream)
IsAuthenticated	Obtém um valor Boolean que indica se a autenticação foi bem-sucedida.
IsEncrypted	Obtém um valor Boolean que indica se esse SslStream usa criptografia de dados.
IsMutuallyAuthenticated	Obtém um valor Boolean que indica se o servidor e o cliente foram autenticados.
IsServer	Obtém um valor Boolean que indica se o lado local da conexão usada por esse SslStream foi autenticado como o servidor.
IsSigned	Obtém um valor Boolean que indica se os dados enviados usando esse fluxo estão assinados.
KeyExchangeAlgorithm	Obtém o algoritmo de troca de chaves usado por este SslStream.
KeyExchangeStrength	Obtém um valor que identifica a força do algoritmo de troca de chaves usado por essa instância.
LeaveInnerStreamOpen	Obtém se o fluxo usado por esse AuthenticatedStream para enviar e receber dados foi deixado aberto. (Herdado de AuthenticatedStream)
Length	Obtém o comprimento do fluxo subjacente.
LocalCertificate	Obtém o certificado usado para autenticar o ponto de extremidade local.
NegotiatedApplicationProtocol	O protocolo de aplicativo negociado no handshake do TLS.
NegotiatedCipherSuite	Obtém o conjunto de criptografias que foi negociado para essa conexão.
Position	Obtém ou define a posição atual no fluxo subjacente.
ReadTimeout	Obtém ou define a quantidade de tempo, expressa em milissegundos, um bloco de operação de leitura aguardando dados.
RemoteCertificate	Obtém o certificado usado para autenticar o ponto de extremidade remoto.
SslProtocol	Obtém um valor que indica o protocolo de segurança usado para autenticar essa conexão.
TargetHostName	Obtém o nome do servidor ao qual o cliente está tentando se conectar. Esse nome é usado para validação de certificado do servidor. Pode ser um nome DNS ou um endereço IP.
TransportContext	Obtém o TransportContext usado para autenticação usando a proteção estendida.
WriteTimeout	Obtém ou define a quantidade de tempo que uma operação de gravação bloqueia aguardando dados.

Métodos

AuthenticateAsClient(SslClientAuthenticationOptions)	Chamado por clientes para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor.
AuthenticateAsClient(String)	Chamado por clientes para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor.
AuthenticateAsClient(String, X509CertificateCollection, Boolean)	Chamado por clientes para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor. O processo de autenticação usa a coleção de certificados especificada e o protocolo SSL padrão do sistema.
AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)	Chamado por clientes para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor. O processo de autenticação usa a coleção de certificados e o protocolo SSL especificados.
AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)	Chamado pelos clientes para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa informações especificadas no recipiente de propriedades sslClientAuthenticationOptions.
AuthenticateAsClientAsync(String)	Chamado pelos clientes para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor como uma operação assíncrona.
AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)	Chamado pelos clientes para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa a coleção de certificados especificada e o protocolo SSL padrão do sistema.
AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)	Chamado pelos clientes para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa a coleção de certificados e o protocolo SSL especificados.
AuthenticateAsServer(SslServerAuthenticationOptions)	Chamado por servidores para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor usando o certificado especificado.
AuthenticateAsServer(X509Certificate)	Chamado por servidores para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor usando o certificado especificado.
AuthenticateAsServer(X509Certificate, Boolean, Boolean)	Chamado por servidores para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor usando os certificados e requisitos especificados e usando o protocolo de segurança padrão do sistema.
AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)	Chamado por servidores para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor usando os certificados, requisitos e protocolo de segurança especificados.
AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken)	Chamado por servidores para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa informações retornadas por optionsCallback.
AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)	Chamado por servidores para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa informações especificadas no recipiente de propriedades sslClientAuthenticationOptions.
AuthenticateAsServerAsync(X509Certificate)	Chamado por servidores para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor usando o certificado especificado como uma operação assíncrona.
AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)	Chamado por servidores para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor usando os certificados, requisitos e protocolo de segurança especificados como uma operação assíncrona.
AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)	Chamado por servidores para autenticar o servidor e, opcionalmente, o cliente em uma conexão cliente-servidor usando os certificados, requisitos e protocolo de segurança especificados como uma operação assíncrona.
BeginAuthenticateAsClient(String, AsyncCallback, Object)	Chamado pelos clientes para iniciar uma operação assíncrona para autenticar o servidor e, opcionalmente, o cliente.
BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)	Chamado pelos clientes para iniciar uma operação assíncrona para autenticar o servidor e, opcionalmente, o cliente usando os certificados especificados e o protocolo de segurança padrão do sistema.
BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)	Chamado pelos clientes para iniciar uma operação assíncrona para autenticar o servidor e, opcionalmente, o cliente usando os certificados especificados e o protocolo de segurança.
BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)	Chamado por servidores para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor em uma conexão cliente-servidor.
BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)	Chamado por servidores para iniciar uma operação assíncrona para autenticar o servidor e, opcionalmente, o cliente usando os certificados e requisitos especificados e o protocolo de segurança padrão do sistema.
BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)	Chamado por servidores para iniciar uma operação assíncrona para autenticar o servidor e, opcionalmente, o cliente usando os certificados, requisitos e protocolo de segurança especificados.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de leitura assíncrona que lê dados do fluxo e os armazena na matriz especificada.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de gravação assíncrona que grava Bytes do buffer especificado no fluxo.
Close()	Fecha o fluxo atual e libera todos os recursos (como soquetes e identificadores de arquivo) associados ao fluxo atual. Em vez de chamar esse método, verifique se o fluxo foi descartado corretamente. (Herdado de Stream)
CopyTo(Stream)	Lê os bytes do fluxo atual e os grava em outro fluxo. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyTo(Stream, Int32)	Lê os bytes do fluxo atual e os grava em outro fluxo, usando um tamanho de buffer especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream)	Lê assíncronamente os bytes do fluxo atual e os grava em outro fluxo. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, CancellationToken)	Lê assíncronamente os bytes do fluxo atual e os grava em outro fluxo, usando um token de cancelamento especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, Int32)	Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo, usando um tamanho de buffer especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lê assíncronamente os bytes do fluxo atual e os grava em outro fluxo, usando um token de cancelamento e tamanho de buffer especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CreateObjRef(Type)	Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject)
CreateWaitHandle()	Obsoleto. Aloca um objeto WaitHandle. (Herdado de Stream)
Dispose()	Libera todos os recursos usados pelo Stream. (Herdado de Stream)
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo SslStream e, opcionalmente, libera os recursos gerenciados.
DisposeAsync()	Libera de forma assíncrona os recursos não gerenciados e gerenciados usados pelo SslStream.
EndAuthenticateAsClient(IAsyncResult)	Encerra uma operação de autenticação de servidor assíncrona pendente iniciada com uma chamada anterior para BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Encerra uma operação de autenticação de cliente assíncrona pendente iniciada com uma chamada anterior para BeginAuthenticateAsClient.
EndRead(IAsyncResult)	Encerra uma operação de leitura assíncrona iniciada com uma chamada anterior para BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Encerra uma operação de gravação assíncrona iniciada com uma chamada anterior para BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
Finalize()	Libera todos os recursos usados pelo SslStream.
Flush()	Faz com que todos os dados em buffer sejam gravados no dispositivo subjacente.
FlushAsync()	Limpa de forma assíncrona todos os buffers para esse fluxo e faz com que todos os dados em buffer sejam gravados no dispositivo subjacente. (Herdado de Stream)
FlushAsync(CancellationToken)	Grava de forma assíncrona todos os dados em buffer no dispositivo subjacente.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLifetimeService()	Obsoleto. Recupera o objeto de serviço de tempo de vida atual que controla a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
InitializeLifetimeService()	Obsoleto. Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida dessa instância. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)	Negocia o certificado do cliente na conexão autenticada.
ObjectInvariant()	Obsoleto. Fornece suporte para um Contract. (Herdado de Stream)
Read(Byte[], Int32, Int32)	Lê dados desse fluxo e os armazena na matriz especificada.
Read(Span<Byte>)	Quando substituído em uma classe derivada, lê uma sequência de bytes do fluxo atual e avança a posição dentro do fluxo pelo número de bytes lidos. (Herdado de Stream)
ReadAsync(Byte[], Int32, Int32)	Lê de forma assíncrona uma sequência de bytes do fluxo atual e avança a posição dentro do fluxo pelo número de bytes lidos. (Herdado de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lê de forma assíncrona os dados desse fluxo e os armazena no intervalo especificado de uma matriz de bytes.
ReadAsync(Memory<Byte>, CancellationToken)	Lê de forma assíncrona os dados desse fluxo e os armazena no intervalo de memória especificado.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Lê pelo menos um número mínimo de bytes do fluxo atual e avança a posição dentro do fluxo pelo número de bytes lidos. (Herdado de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Lê de forma assíncrona pelo menos um número mínimo de bytes do fluxo atual, avança a posição dentro do fluxo pelo número de bytes lidos e monitora solicitações de cancelamento. (Herdado de Stream)
ReadByte()	Lê um byte do SslStream e avança a posição dentro do fluxo por um byte ou retorna -1 se estiver no final do fluxo.
ReadExactly(Byte[], Int32, Int32)	Lê count número de bytes do fluxo atual e avança a posição dentro do fluxo. (Herdado de Stream)
ReadExactly(Span<Byte>)	Lê bytes do fluxo atual e avança a posição dentro do fluxo até que a buffer seja preenchida. (Herdado de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Lê de forma assíncrona count número de bytes do fluxo atual, avança a posição dentro do fluxo e monitora solicitações de cancelamento. (Herdado de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Lê bytes de forma assíncrona do fluxo atual, avança a posição dentro do fluxo até que o buffer seja preenchido e monitore as solicitações de cancelamento. (Herdado de Stream)
Seek(Int64, SeekOrigin)	Lança um NotSupportedException.
SetLength(Int64)	Define o comprimento do fluxo subjacente.
ShutdownAsync()	Desliga este SslStream.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
Write(Byte[])	Grava os dados especificados nesse fluxo.
Write(Byte[], Int32, Int32)	Escreva o número especificado de Bytes no fluxo subjacente usando o buffer e o deslocamento especificados.
Write(ReadOnlySpan<Byte>)	Quando substituído em uma classe derivada, grava uma sequência de bytes no fluxo atual e avança a posição atual dentro desse fluxo pelo número de bytes gravados. (Herdado de Stream)
WriteAsync(Byte[], Int32, Int32)	Grava de forma assíncrona uma sequência de bytes no fluxo atual e avança a posição atual dentro desse fluxo pelo número de bytes gravados. (Herdado de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Grava dados de forma assíncrona no fluxo subjacente do intervalo especificado de uma matriz de bytes.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Grava dados de forma assíncrona no fluxo subjacente de um intervalo de memória de bytes somente leitura.
WriteByte(Byte)	Grava um byte na posição atual no fluxo e avança a posição dentro do fluxo por um byte. (Herdado de Stream)

Métodos de Extensão

CopyToAsync(Stream, PipeWriter, CancellationToken)	Lê assíncronamente os bytes do Stream e os grava no PipeWriterespecificado usando um token de cancelamento.
ConfigureAwait(IAsyncDisposable, Boolean)	Configura como as esperas nas tarefas retornadas de um descartável assíncrono serão executadas.

Confira também

• NegotiateStream
• AuthenticatedStream
• IOException
• Stream