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

Poniższy przykład kodu przedstawia tworzenie klasy TcpListener , która używa SslStream klasy 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 klasy, która używa SslStream klasy 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 elementu SslStream. Połączenie SSL, takie jak podane przez SslStreamusługę , powinno być używane podczas komunikowania poufnych informacji między klientem a serwerem. Korzystanie z narzędzia SslStream pomaga uniemożliwić każdemu odczytywanie i manipulowanie informacjami podczas ich przesyłania w sieci.

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

Po utworzeniu SslStreamserwera i opcjonalnie klient musi zostać uwierzytelniony. 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 elementu SslStream. Klienci inicjują uwierzytelnianie przy użyciu metod synchronicznych AuthenticateAsClient , które blokują do momentu ukończenia uwierzytelniania lub metod asynchronicznych BeginAuthenticateAsClient , które nie blokują oczekiwania na ukończenie uwierzytelniania. Serwery inicjują uwierzytelnianie przy użyciu metod synchronicznych AuthenticateAsServer lub asynchronicznych BeginAuthenticateAsServer . Zarówno klient, jak i serwer muszą zainicjować uwierzytelnianie.

Uwierzytelnianie jest obsługiwane przez dostawcę kanału dostawcy usług pomocy technicznej zabezpieczeń (SSPI). Klient ma możliwość kontrolowania weryfikacji certyfikatu serwera przez określenie RemoteCertificateValidationCallback delegata podczas tworzenia obiektu SslStream. Serwer może również kontrolować walidację, podając delegata RemoteCertificateValidationCallback . Metoda przywoływana przez delegata zawiera certyfikat jednostki zdalnej i wszelkie błędy 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 uwierzytelniania. Jeśli klient ma więcej niż jeden certyfikat, klient może podać delegata LocalCertificateSelectionCallback , 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 w Ssl2 przypadku protokołu SSL w wersji 2.

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

Gdy proces uwierzytelniania, znany również jako uzgadnianie ssl, zakończy się powodzeniem, tożsamość serwera (i opcjonalnie klient) zostanie ustanowiona i SslStream może być używana 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 program SslStream w celu określenia, czy protokół, algorytmy i siły wybrane 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 SslStream za pomocą IsEncrypted właściwości i IsSigned można sprawdzić. W poniższej tabeli przedstawiono elementy, które raportują ustawienia kryptograficzne używane do uwierzytelniania, szyfrowania i podpisywania danych.

Element	Elementy członkowskie
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 komunikatów.	Właściwość CipherAlgorithm i skojarzone CipherAlgorithmType wyliczenie.
Zalety wybranych algorytmów.	Właściwości KeyExchangeStrength, HashStrengthi CipherStrength .

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

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

Uwaga

Jeśli aplikacja, która tworzy SslStream obiekt, 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 komputera lokalnego, chyba że uprawnienie zostało jawnie przyznane użytkownikowi w tym celu.

SslStream zakłada, że przekroczenie limitu 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 przy użyciu SslStream wystąpienia po przekroczeniu limitu czasu spowoduje zwrócenie pamięci. Aplikacja powinna zgłaszać CloseSslStream wyjątek i w takich przypadkach.

.NET Framework 4.6 zawiera nową funkcję zabezpieczeń, która blokuje niezabezpieczone algorytmy szyfrowania i tworzenia 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 określania wartości docelowych .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.

.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ę upływu czasu zmian najlepszych rozwiązań dotyczących wersji protokołu TLS bez konieczności ponownego kompilowania i ponownego wdrażania aplikacji.

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

Konstruktory

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

Właściwości

CanRead	Pobiera wartość wskazującą Boolean , czy bazowy strumień jest czytelny.
CanSeek	Pobiera wartość wskazującą Boolean , czy bazowy strumień można wyszukiwać.
CanTimeout	Pobiera wartość wskazującą Boolean , czy bazowy strumień obsługuje limity czasu.
CanWrite	Pobiera wartość wskazującą Boolean , czy bazowy strumień jest zapisywalny.
CheckCertRevocationStatus	Pobiera wartość wskazującą Boolean , czy lista odwołania certyfikatów jest sprawdzana podczas procesu weryfikacji certyfikatu.
CipherAlgorithm	Pobiera wartość identyfikującą algorytm szyfrowania zbiorczego używany przez ten SslStreamelement .
CipherStrength	Pobiera wartość identyfikującą siłę algorytmu szyfrowania używanego przez ten SslStreamelement .
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 funkcję do wysyłania i odbierania danych. (Odziedziczone po AuthenticatedStream)
IsAuthenticated	Pobiera wartość wskazującą Boolean , czy uwierzytelnianie zakończyło się pomyślnie.
IsEncrypted	Pobiera wartość wskazującą Boolean , czy używa to SslStream szyfrowania danych.
IsMutuallyAuthenticated	Pobiera wartość wskazującą Boolean , czy zarówno serwer, jak i klient zostały uwierzytelnione.
IsServer	Pobiera wartość wskazującą Boolean , czy lokalna strona połączenia użytego przez to SslStream zostało uwierzytelnione jako serwer.
IsSigned	Pobiera wartość wskazującą Boolean , czy dane wysyłane przy użyciu tego strumienia są podpisane.
KeyExchangeAlgorithm	Pobiera algorytm wymiany kluczy używany przez ten SslStreamelement .
KeyExchangeStrength	Pobiera wartość identyfikującą siłę algorytmu wymiany kluczy używanego przez to wystąpienie.
LeaveInnerStreamOpen	Pobiera informację, czy strumień używany przez tę AuthenticatedStream funkcję 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 pakiet szyfrowania, który został wynegocjowany dla tego połączenia.
Position	Pobiera lub ustawia bieżącą pozycję w strumieniu bazowym.
ReadTimeout	Pobiera lub ustawia czas wyrażony 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órego klient próbuje nawiązać połączenie. Ta nazwa jest używana do walidacji certyfikatu serwera. Może to być nazwa DNS lub adres IP.
TransportContext	Pobiera dane używane do uwierzytelniania przy użyciu rozszerzonej TransportContext ochrony.
WriteTimeout	Pobiera lub ustawia czas, przez jaki operacja zapisu blokuje oczekiwanie na dane.

Metody

AuthenticateAsClient(SslClientAuthenticationOptions)	Wywoływane przez klientów w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer.
AuthenticateAsClient(String)	Wywoływane przez klientów w celu uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer.
AuthenticateAsClient(String, X509CertificateCollection, Boolean)	Wywoływane przez klientów w celu uwierzytelniania 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 uwierzytelniania serwera i opcjonalnie klienta w połączeniu klient-serwer. W procesie uwierzytelniania jest używana określona kolekcja certyfikatów i protokół 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 torbie sslClientAuthenticationOptions 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. W procesie uwierzytelniania jest używana określona kolekcja certyfikatów i protokół 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 optionsCallbackprogram .
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 torbie sslClientAuthenticationOptions 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, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia serwera i opcjonalnie klienta.
BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)	Wywoływane przez klientów, aby rozpocząć operację asynchroniczną 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, aby rozpocząć operację asynchroniczną 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. Oba 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. Oba 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. Oba 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. Oba 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. Oba 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. Oba 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. WaitHandle Przydziela obiekt. (Odziedziczone po Stream)
Dispose()	Zwalnia wszelkie zasoby używane przez element Stream. (Odziedziczone po Stream)
Dispose(Boolean)	Zwalnia zasoby niezarządzane używane przez element SslStream i opcjonalnie zwalnia zasoby zarządzane.
DisposeAsync()	Asynchronicznie zwalnia niezarządzane i zarządzane zasoby używane przez SslStreamprogram .
EndAuthenticateAsClient(IAsyncResult)	Kończy oczekującą operację uwierzytelniania asynchronicznego serwera uruchomioną z poprzednim wywołaniem metody BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Kończy oczekującą operację uwierzytelniania asynchronicznego klienta uruchomioną z poprzednim wywołaniem metody BeginAuthenticateAsClient.
EndRead(IAsyncResult)	Kończy asynchroniczną operację odczytu rozpoczętą z poprzednim wywołaniem metody BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Kończy asynchroniczną operację zapisu rozpoczętą z poprzednim wywołaniem metody BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
Finalize()	Zwalnia wszelkie zasoby używane przez element SslStream.
Flush()	Powoduje zapisanie wszystkich buforowanych danych na urządzeniu bazowym.
FlushAsync()	Asynchronicznie czyści wszystkie bufory 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()	Type Pobiera bieżące wystąpienie. (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 Objectelementu . (Odziedziczone po Object)
MemberwiseClone(Boolean)	Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu. (Odziedziczone po MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)	Negocjuje certyfikat klienta w uwierzytelnionych połączeniach.
ObjectInvariant()	Przestarzałe. Zapewnia obsługę programu Contract. (Odziedziczone po Stream)
Read(Byte[], Int32, Int32)	Odczytuje dane z tego strumienia i przechowuje je w określonej tablicy.
Read(Span<Byte>)	Po zastąpieniu w klasie pochodnej odczytuje sekwencję bajtów z bieżącego strumienia i przesuwa pozycję w strumieniu przez liczbę odczytanych bajtów. (Odziedziczone po Stream)
ReadAsync(Byte[], Int32, Int32)	Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia i rozwija pozycję w strumieniu przez liczbę 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 przez liczbę 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 i SslStream zwiększa pozycję w strumieniu według jednego bajtu lub zwraca wartość -1, jeśli na końcu strumienia.
ReadExactly(Byte[], Int32, Int32)	Odczytuje count liczbę bajtów z bieżącego strumienia i przesuwa pozycję w strumieniu. (Odziedziczone po Stream)
ReadExactly(Span<Byte>)	Odczytuje bajty z bieżącego strumienia i przesuwa pozycję w strumieniu do buffer momentu wypełnienia. (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, przesuwa pozycję w strumieniu do buffer momentu wypełnienia i monitoruje żądania anulowania. (Odziedziczone po Stream)
Seek(Int64, SeekOrigin)	Zgłasza element NotSupportedException.
SetLength(Int64)	Ustawia długość bazowego strumienia.
ShutdownAsync()	Wyłącza ten protokół 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 strumienia bazowego 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 przesuwa pozycję w strumieniu o jeden bajt. (Odziedziczone po Stream)

Metody rozszerzania

CopyToAsync(Stream, PipeWriter, CancellationToken)	Asynchronicznie odczytuje bajty z obiektu Stream i zapisuje je w określonym PipeWriterobiekcie przy użyciu tokenu anulowania.
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguruje sposób oczekiwania na zadania zwracane z asynchronicznego jednorazowego wykonania.

Zobacz też

• NegotiateStream
• AuthenticatedStream
• IOException
• Stream