SslStream Klasa

Definicja

Przestrzeń nazw:

System.Net.Security

Zestaw:

System.Net.Security.dll

Źródło:

SslStream.cs

Udostępnia strumień używany do komunikacji klient-serwer, który używa protokołu zabezpieczeń Secure Socket Layer (SSL) do uwierzytelniania serwera i opcjonalnie klienta.

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

public class SslStream : System.Net.Security.AuthenticatedStream

type SslStream = class
    inherit AuthenticatedStream

Public Class SslStream
Inherits AuthenticatedStream

Dziedziczenie

Object

MarshalByRefObject

Stream

AuthenticatedStream

SslStream

Przykłady

W poniższym przykładzie kodu pokazano tworzenie TcpListener, które używa klasy SslStream do komunikowania się z klientami.

#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

Poniższy przykład kodu przedstawia tworzenie TcpClient, która używa klasy SslStream do komunikowania się z serwerem.

#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

Uwagi

Protokoły SSL pomagają zapewnić poufność i sprawdzanie integralności komunikatów przesyłanych przy użyciu SslStream. Połączenie SSL, takie jak podane przez SslStream, powinno być używane podczas komunikowania poufnych informacji między klientem a serwerem. Korzystanie z SslStream pomaga zapobiec odczytywaniu i manipulowaniu informacjami podczas ich przesyłania w sieci.

Wystąpienie SslStream przesyła dane przy użyciu strumienia dostarczanego podczas tworzenia SslStream. Po podaniu tego bazowego strumienia możesz określić, czy zamknięcie SslStream również zamyka bazowy strumień. Zazwyczaj klasa SslStream jest używana z klasami TcpClient i TcpListener. Metoda GetStream zapewnia NetworkStream odpowiednie do użycia z klasą SslStream.

Po utworzeniu SslStreamserwer i opcjonalnie należy uwierzytelnić klienta. Serwer musi podać certyfikat X509, który ustanawia dowód jego tożsamości i może zażądać, aby klient również to zrobił. Uwierzytelnianie należy wykonać przed przesłaniem informacji przy użyciu SslStream. Klienci inicjują uwierzytelnianie przy użyciu metod synchronicznych AuthenticateAsClient, które blokują się do momentu zakończenia uwierzytelniania lub metod asynchronicznych BeginAuthenticateAsClient, które nie blokują oczekiwania na ukończenie uwierzytelniania. Serwery inicjują uwierzytelnianie przy użyciu synchronicznych metod AuthenticateAsServer lub asynchronicznych BeginAuthenticateAsServer. Zarówno klient, jak i serwer muszą zainicjować uwierzytelnianie.

Uwierzytelnianie jest obsługiwane przez dostawcę kanału dostawcy usług obsługi zabezpieczeń (SSPI). Klient ma możliwość kontrolowania weryfikacji certyfikatu serwera przez określenie delegata RemoteCertificateValidationCallback podczas tworzenia SslStream. Serwer może również kontrolować walidację, podając delegata RemoteCertificateValidationCallback. Metoda przywoływana przez delegata zawiera certyfikat strony zdalnej i wszelkie błędy SSPI napotkane podczas sprawdzania poprawności certyfikatu. Należy pamiętać, że jeśli serwer określa delegata, metoda delegata jest wywoływana niezależnie od tego, czy serwer zażądał uwierzytelniania klienta. Jeśli serwer nie zażądał uwierzytelniania klienta, metoda delegata serwera odbiera certyfikat o wartości null i pustą tablicę błędów certyfikatu.

Jeśli serwer wymaga uwierzytelniania klienta, klient musi określić co najmniej jeden certyfikat na potrzeby uwierzytelniania. Jeśli klient ma więcej niż jeden certyfikat, klient może dostarczyć LocalCertificateSelectionCallback delegata, aby wybrać prawidłowy certyfikat dla serwera. Certyfikaty klienta muszą znajdować się w magazynie certyfikatów bieżącego użytkownika "Mój". Uwierzytelnianie klienta za pośrednictwem certyfikatów nie jest obsługiwane dla protokołu Ssl2 (SSL w wersji 2).

Jeśli uwierzytelnianie zakończy się niepowodzeniem, otrzymasz AuthenticationException, a SslStream nie będzie już możliwe do użycia. Należy zamknąć ten obiekt i usunąć wszystkie odwołania do niego, aby można było go zebrać przez moduł odśmiecający pamięci.

Gdy proces uwierzytelniania, znany również jako uzgadnianie SSL, kończy się powodzeniem, tożsamość serwera (i opcjonalnie klient) jest ustanawiana, a SslStream może być używany przez klienta i serwer do wymiany komunikatów. Przed wysłaniem lub odebraniem informacji klient i serwer powinny sprawdzić usługi zabezpieczeń i poziomy udostępniane przez SslStream w celu ustalenia, czy wybrany protokół, algorytmy i mocne strony spełniają wymagania dotyczące integralności i poufności. Jeśli bieżące ustawienia nie są wystarczające, strumień powinien zostać zamknięty. Usługi zabezpieczeń udostępniane przez SslStream można sprawdzić przy użyciu właściwości IsEncrypted i IsSigned. W poniższej tabeli przedstawiono elementy raportujące ustawienia kryptograficzne używane do uwierzytelniania, szyfrowania i podpisywania danych.

Pierwiastek	Członków
Protokół zabezpieczeń używany do uwierzytelniania serwera i, opcjonalnie, klienta.	Właściwość SslProtocol i skojarzone SslProtocols wyliczenie.
Algorytm wymiany kluczy.	Właściwość KeyExchangeAlgorithm i skojarzone ExchangeAlgorithmType wyliczenie.
Algorytm integralności komunikatów.	Właściwość HashAlgorithm i skojarzone HashAlgorithmType wyliczenie.
Algorytm poufności wiadomości.	Właściwość CipherAlgorithm i skojarzone CipherAlgorithmType wyliczenie.
Mocne strony wybranych algorytmów.	Właściwości KeyExchangeStrength, HashStrengthi CipherStrength.

Po pomyślnym uwierzytelnieniu można wysyłać dane przy użyciu synchronicznych metod Write lub asynchronicznych BeginWrite. Dane można odbierać przy użyciu metod synchronicznych Read lub asynchronicznych BeginRead.

Jeśli określono SslStream, że źródłowy strumień powinien być otwarty, użytkownik jest odpowiedzialny za zamknięcie tego strumienia po zakończeniu korzystania z niego.

Nuta

Jeśli aplikacja tworząca obiekt SslStream jest uruchamiana przy użyciu poświadczeń normalnego użytkownika, aplikacja nie będzie mogła uzyskać dostępu do certyfikatów zainstalowanych w magazynie komputerów lokalnych, chyba że użytkownikowi jawnie nadano to uprawnienie.

SslStream zakłada, że limit czasu wraz z innymi IOException, gdy jeden zostanie wyrzucony ze strumienia wewnętrznego, będzie traktowany jako krytyczny przez jego obiekt wywołujący. Ponowne tworzenie wystąpienia SslStream po przekroczeniu limitu czasu spowoduje zwrócenie pamięci. Aplikacja powinna CloseSslStream i zgłaszać wyjątek w tych przypadkach.

Program .NET Framework 4.6 zawiera nową funkcję zabezpieczeń, która blokuje niezabezpieczone algorytmy szyfrowania i skrótów dla połączeń. Aplikacje korzystające z protokołu TLS/SSL za pośrednictwem interfejsów API, takich jak HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream itp. i przeznaczone dla platformy .NET Framework 4.6 domyślnie uzyskują bezpieczniejsze zachowanie.

Deweloperzy mogą zrezygnować z tego zachowania, aby zachować współdziałanie z istniejącymi usługami SSL3 lub TLS w/ RC4. w tym artykule wyjaśniono, jak zmodyfikować kod tak, aby nowe zachowanie było wyłączone.

Program .NET Framework 4.7 dodaje nowe przeciążenia dla metod uwierzytelniania SslStreams, które nie określają wersji protokołu TLS, ale zamiast tego używają wersji protokołu TLS zdefiniowanej jako domyślna wersja systemu w SCHANNEL. Użyj tych metod w aplikacji jako sposobu późniejszego zmodyfikowania wartości domyślnych w miarę zmiany najlepszych rozwiązań wersji protokołu TLS w miarę upływu czasu bez konieczności ponownego kompilowania i ponownego wdrażania aplikacji.

Zobacz również Transport Layer Security (TLS) najlepsze rozwiązania dotyczące programu .NET Framework.

Konstruktory

SslStream(Stream)	Inicjuje nowe wystąpienie klasy SslStream przy użyciu określonego Stream.
SslStream(Stream, Boolean)	Inicjuje nowe wystąpienie klasy SslStream przy użyciu określonego zachowania Stream i zamknięcia strumienia.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback)	Inicjuje nowe wystąpienie klasy SslStream przy użyciu określonego Stream, zachowania zamknięcia strumienia i delegata weryfikacji certyfikatu.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)	Inicjuje nowe wystąpienie klasy SslStream przy użyciu określonego Stream, zachowania zamknięcia strumienia, delegata weryfikacji certyfikatu i delegata wyboru certyfikatu.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)	Inicjuje nowe wystąpienie klasy SslStream przy użyciu określonego Stream.

Właściwości

CanRead	Pobiera wartość Boolean wskazującą, czy źródłowy strumień jest czytelny.
CanSeek	Pobiera wartość Boolean, która wskazuje, czy podstawowy strumień można wyszukiwać.
CanTimeout	Pobiera wartość Boolean wskazującą, czy bazowy strumień obsługuje limity czasu.
CanWrite	Pobiera wartość Boolean wskazującą, czy bazowy strumień jest zapisywalny.
CheckCertRevocationStatus	Pobiera wartość Boolean wskazującą, czy lista odwołania certyfikatów jest sprawdzana podczas procesu weryfikacji certyfikatu.
CipherAlgorithm	Pobiera wartość identyfikującą algorytm szyfrowania zbiorczego używany przez ten SslStream.
CipherStrength	Pobiera wartość identyfikującą siłę algorytmu szyfrowania używanego przez ten SslStream.
HashAlgorithm	Pobiera algorytm używany do generowania kodów uwierzytelniania komunikatów (MACs).
HashStrength	Pobiera wartość identyfikującą siłę algorytmu skrótu używanego przez to wystąpienie.
InnerStream	Pobiera strumień używany przez tę AuthenticatedStream do wysyłania i odbierania danych. (Odziedziczone po AuthenticatedStream)
IsAuthenticated	Pobiera wartość Boolean wskazującą, czy uwierzytelnianie zakończyło się pomyślnie.
IsEncrypted	Pobiera wartość Boolean wskazującą, czy ta SslStream używa szyfrowania danych.
IsMutuallyAuthenticated	Pobiera wartość Boolean wskazującą, czy zarówno serwer, jak i klient zostały uwierzytelnione.
IsServer	Pobiera wartość Boolean wskazującą, czy lokalna strona połączenia używanego przez tę SslStream została uwierzytelniona jako serwer.
IsSigned	Pobiera wartość Boolean wskazującą, czy dane wysyłane przy użyciu tego strumienia są podpisane.
KeyExchangeAlgorithm	Pobiera algorytm wymiany kluczy używany przez ten SslStream.
KeyExchangeStrength	Pobiera wartość identyfikującą siłę algorytmu wymiany kluczy używanego przez to wystąpienie.
LeaveInnerStreamOpen	Pobiera, czy strumień używany przez ten AuthenticatedStream do wysyłania i odbierania danych został otwarty. (Odziedziczone po AuthenticatedStream)
Length	Pobiera długość bazowego strumienia.
LocalCertificate	Pobiera certyfikat używany do uwierzytelniania lokalnego punktu końcowego.
NegotiatedApplicationProtocol	Wynegocjowany protokół aplikacji w uzgadnianiu protokołu TLS.
NegotiatedCipherSuite	Pobiera zestaw szyfrowania, który został wynegocjowany dla tego połączenia.
Position	Pobiera lub ustawia bieżące położenie w strumieniu bazowym.
ReadTimeout	Pobiera lub ustawia ilość czasu wyrażonego w milisekundach, bloki operacji odczytu oczekujące na dane.
RemoteCertificate	Pobiera certyfikat używany do uwierzytelniania zdalnego punktu końcowego.
SslProtocol	Pobiera wartość wskazującą protokół zabezpieczeń używany do uwierzytelniania tego połączenia.
TargetHostName	Pobiera nazwę serwera, z którą klient próbuje nawiązać połączenie. Ta nazwa jest używana do weryfikacji certyfikatu serwera. Może to być nazwa DNS lub adres IP.
TransportContext	Pobiera TransportContext używane do uwierzytelniania przy użyciu rozszerzonej ochrony.
WriteTimeout	Pobiera lub ustawia czas, przez jaki operacja zapisu blokuje oczekiwanie na dane.

Metody

AuthenticateAsClient(SslClientAuthenticationOptions)	Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniu klient-serwer.
AuthenticateAsClient(String)	Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniu klient-serwer.
AuthenticateAsClient(String, X509CertificateCollection, Boolean)	Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniu klient-serwer. Proces uwierzytelniania używa określonej kolekcji certyfikatów i domyślnego protokołu SSL systemu.
AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)	Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniu klient-serwer. Proces uwierzytelniania używa określonej kolekcji certyfikatów i protokołu SSL.
AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)	Wywoływane przez klientów w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa informacji określonych w sslClientAuthenticationOptions worku właściwości.
AuthenticateAsClientAsync(String)	Wywoływane przez klientów w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer jako operacja asynchroniczna.
AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)	Wywoływane przez klientów w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonej kolekcji certyfikatów i domyślnego protokołu SSL systemu.
AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)	Wywoływane przez klientów w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonej kolekcji certyfikatów i protokołu SSL.
AuthenticateAsServer(SslServerAuthenticationOptions)	Wywoływane przez serwery w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer przy użyciu określonego certyfikatu.
AuthenticateAsServer(X509Certificate)	Wywoływane przez serwery w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer przy użyciu określonego certyfikatu.
AuthenticateAsServer(X509Certificate, Boolean, Boolean)	Wywoływane przez serwery w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer przy użyciu określonych certyfikatów i wymagań oraz przy użyciu domyślnego protokołu zabezpieczeń systemu.
AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)	Wywoływane przez serwery w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer przy użyciu określonych certyfikatów, wymagań i protokołu zabezpieczeń.
AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken)	Wywoływane przez serwery w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa informacji zwracanych przez optionsCallback.
AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)	Wywoływane przez serwery w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa informacji określonych w sslClientAuthenticationOptions worku właściwości.
AuthenticateAsServerAsync(X509Certificate)	Wywoływane przez serwery w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer przy użyciu określonego certyfikatu jako operacji asynchronicznej.
AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)	Wywoływane przez serwery w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer przy użyciu określonych certyfikatów, wymagań i protokołu zabezpieczeń jako operacji asynchronicznej.
AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)	Wywoływane przez serwery w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer przy użyciu określonych certyfikatów, wymagań i protokołu zabezpieczeń jako operacji asynchronicznej.
BeginAuthenticateAsClient(String, AsyncCallback, Object)	Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia serwera i opcjonalnie klienta.
BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)	Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia serwera i opcjonalnie klienta przy użyciu określonych certyfikatów i domyślnego protokołu zabezpieczeń systemu.
BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)	Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia serwera i opcjonalnie klienta przy użyciu określonych certyfikatów i protokołu zabezpieczeń.
BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)	Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer.
BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)	Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia serwera i opcjonalnie klienta przy użyciu określonych certyfikatów i wymagań oraz domyślnego protokołu zabezpieczeń systemu.
BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)	Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia serwera i opcjonalnie klienta przy użyciu określonych certyfikatów, wymagań i protokołu zabezpieczeń.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Rozpoczyna asynchroniczną operację odczytu, która odczytuje dane ze strumienia i zapisuje je w określonej tablicy.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Rozpoczyna asynchroniczną operację zapisu, która zapisuje Bytes z określonego buforu do strumienia.
Close()	Zamyka bieżący strumień i zwalnia wszystkie zasoby (takie jak gniazda i dojścia plików) skojarzone z bieżącym strumieniem. Zamiast wywoływać tę metodę, upewnij się, że strumień jest prawidłowo usuwany. (Odziedziczone po Stream)
CopyTo(Stream)	Odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CopyTo(Stream, Int32)	Odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CopyToAsync(Stream)	Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CopyToAsync(Stream, CancellationToken)	Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego tokenu anulowania. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CopyToAsync(Stream, Int32)	Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu i tokenu anulowania. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CreateObjRef(Type)	Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym. (Odziedziczone po MarshalByRefObject)
CreateWaitHandle()	Przestarzałe. Przydziela obiekt WaitHandle. (Odziedziczone po Stream)
Dispose()	Zwalnia wszystkie zasoby używane przez Stream. (Odziedziczone po Stream)
Dispose(Boolean)	Zwalnia niezarządzane zasoby używane przez SslStream i opcjonalnie zwalnia zarządzane zasoby.
DisposeAsync()	Asynchronicznie zwalnia niezarządzane i zarządzane zasoby używane przez SslStream.
EndAuthenticateAsClient(IAsyncResult)	Kończy oczekującą operację uwierzytelniania serwera asynchronicznego rozpoczętą z poprzednim wywołaniem BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Kończy oczekującą operację asynchronicznego uwierzytelniania klienta uruchomioną z poprzednim wywołaniem BeginAuthenticateAsClient.
EndRead(IAsyncResult)	Kończy asynchroniczną operację odczytu rozpoczętą z poprzednim wywołaniem BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Kończy asynchroniczną operację zapisu rozpoczętą z poprzednim wywołaniem BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Określa, czy określony obiekt jest równy bieżącemu obiektowi. (Odziedziczone po Object)
Finalize()	Zwalnia wszystkie zasoby używane przez SslStream.
Flush()	Powoduje zapisanie wszystkich buforowanych danych na urządzeniu bazowym.
FlushAsync()	Asynchronicznie czyści wszystkie dla tego strumienia i powoduje zapisanie wszystkich buforowanych danych na urządzeniu bazowym. (Odziedziczone po Stream)
FlushAsync(CancellationToken)	Asynchronicznie zapisuje wszystkie buforowane dane na urządzeniu bazowym.
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetLifetimeService()	Przestarzałe. Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
GetType()	Pobiera Type bieżącego wystąpienia. (Odziedziczone po Object)
InitializeLifetimeService()	Przestarzałe. Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Object. (Odziedziczone po Object)
MemberwiseClone(Boolean)	Tworzy płytkią kopię bieżącego obiektu MarshalByRefObject. (Odziedziczone po MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)	Negocjuje certyfikat klienta dla uwierzytelnionego połączenia.
ObjectInvariant()	Przestarzałe. Zapewnia obsługę Contract. (Odziedziczone po Stream)
Read(Byte[], Int32, Int32)	Odczytuje dane z tego strumienia i przechowuje je w określonej tablicy.
Read(Span<Byte>)	Gdy przesłonięta w klasie pochodnej, odczytuje sekwencję bajtów z bieżącego strumienia i przechodzi pozycję w strumieniu według liczby odczytanych bajtów. (Odziedziczone po Stream)
ReadAsync(Byte[], Int32, Int32)	Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia i rozwija pozycję w strumieniu według liczby odczytanych bajtów. (Odziedziczone po Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronicznie odczytuje dane z tego strumienia i przechowuje je w określonym zakresie tablicy bajtów.
ReadAsync(Memory<Byte>, CancellationToken)	Asynchronicznie odczytuje dane z tego strumienia i przechowuje je w określonym zakresie pamięci.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Odczytuje co najmniej minimalną liczbę bajtów z bieżącego strumienia i rozwija pozycję w strumieniu według liczby odczytanych bajtów. (Odziedziczone po Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Asynchronicznie odczytuje co najmniej minimalną liczbę bajtów z bieżącego strumienia, zwiększa pozycję w strumieniu przez liczbę odczytanych bajtów i monitoruje żądania anulowania. (Odziedziczone po Stream)
ReadByte()	Odczytuje bajt z SslStream i rozwija pozycję w strumieniu według jednego bajtu lub zwraca -1, jeśli na końcu strumienia.
ReadExactly(Byte[], Int32, Int32)	Odczytuje count liczbę bajtów z bieżącego strumienia i rozwija pozycję w strumieniu. (Odziedziczone po Stream)
ReadExactly(Span<Byte>)	Odczytuje bajty z bieżącego strumienia i przesuwa pozycję w strumieniu do momentu wypełnienia buffer. (Odziedziczone po Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronicznie odczytuje count liczbę bajtów z bieżącego strumienia, zwiększa pozycję w strumieniu i monitoruje żądania anulowania. (Odziedziczone po Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Asynchronicznie odczytuje bajty z bieżącego strumienia, przechodzi pozycję w strumieniu do momentu wypełnienia buffer i monitoruje żądania anulowania. (Odziedziczone po Stream)
Seek(Int64, SeekOrigin)	Zgłasza NotSupportedException.
SetLength(Int64)	Ustawia długość bazowego strumienia.
ShutdownAsync()	Zamyka ten element SslStream.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
Write(Byte[])	Zapisuje określone dane w tym strumieniu.
Write(Byte[], Int32, Int32)	Zapisz określoną liczbę Bytes do bazowego strumienia przy użyciu określonego buforu i przesunięcia.
Write(ReadOnlySpan<Byte>)	Po zastąpieniu w klasie pochodnej zapisuje sekwencję bajtów do bieżącego strumienia i przechodzi bieżącą pozycję w tym strumieniu przez liczbę zapisanych bajtów. (Odziedziczone po Stream)
WriteAsync(Byte[], Int32, Int32)	Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia i przechodzi bieżącą pozycję w tym strumieniu przez liczbę zapisanych bajtów. (Odziedziczone po Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronicznie zapisuje dane do bazowego strumienia z określonego zakresu tablicy bajtów.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Asynchronicznie zapisuje dane do bazowego strumienia z zakresu pamięci tylko do odczytu.
WriteByte(Byte)	Zapisuje bajt do bieżącej pozycji w strumieniu i rozwija pozycję w strumieniu według jednego bajtu. (Odziedziczone po Stream)

Metody rozszerzania

CopyToAsync(Stream, PipeWriter, CancellationToken)	Asynchronicznie odczytuje bajty z Stream i zapisuje je w określonym PipeWriterprzy użyciu tokenu anulowania.
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguruje, w jaki sposób będą wykonywane oczekiwania na zadania zwrócone z asynchronicznego jednorazowego użytku.

Zobacz też

• NegotiateStream
• AuthenticatedStream
• IOException
• Stream