SslStream Sınıf

Tanım

Ad Alanı:

System.Net.Security

Bütünleştirilmiş Kod:

System.Net.Security.dll

Kaynak:

SslStream.cs

Sunucunun ve isteğe bağlı olarak istemcinin kimliğini doğrulamak için Güvenli Yuva Katmanı (SSL) güvenlik protokollerini kullanan istemci-sunucu iletişimi için kullanılan bir akış sağlar.

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

Devralma

Object

MarshalByRefObject

Stream

AuthenticatedStream

SslStream

Örnekler

Aşağıdaki kod örneği, istemcilerle iletişim kurmak için SslStream sınıfını kullanan bir TcpListener oluşturmayı gösterir.

#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

Aşağıdaki kod örneği, bir sunucuyla iletişim kurmak için SslStream sınıfını kullanan bir TcpClient oluşturmayı gösterir.

#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

Açıklamalar

SSL protokolleri, SslStreamkullanılarak iletilen iletiler için gizlilik ve bütünlük denetimi sağlamaya yardımcı olur. SslStreamtarafından sağlanan gibi bir SSL bağlantısı, istemci ile sunucu arasında hassas bilgiler iletişim kurarken kullanılmalıdır. SslStream kullanmak, ağ üzerinde aktarım sırasında herkesin bilgileri okumasını ve kurcalamasını önlemeye yardımcı olur.

SslStream örneği, SslStreamoluştururken sağladığınız bir akışı kullanarak veri aktarır. Bu temel akışı sağladığınızda, SslStream kapatıldığında temel alınan akışın da kapatılıp kapatılmayacağını belirtme seçeneğiniz vardır. Genellikle SslStream sınıfı TcpClient ve TcpListener sınıflarıyla birlikte kullanılır. GetStream yöntemi, SslStream sınıfıyla kullanıma uygun bir NetworkStream sağlar.

SslStreamoluşturduktan sonra sunucu ve isteğe bağlı olarak istemcinin kimlik doğrulaması yapılmalıdır. Sunucu, kimliğinin kanıtını oluşturan ve istemcinin de bunu gerçekleştirmesini isteyebilen bir X509 sertifikası sağlamalıdır. Kimlik doğrulaması, SslStreamkullanılarak bilgi iletilmeden önce gerçekleştirilmelidir. İstemciler, kimlik doğrulaması tamamlanana kadar engelleyen zaman uyumlu AuthenticateAsClient yöntemlerini veya kimlik doğrulamasının tamamlanmasını beklemeyi engellemeyen zaman uyumsuz BeginAuthenticateAsClient yöntemlerini kullanarak kimlik doğrulamasını başlatır. Sunucular zaman uyumlu AuthenticateAsServer veya zaman uyumsuz BeginAuthenticateAsServer yöntemlerini kullanarak kimlik doğrulamasını başlatır. Hem istemci hem de sunucu kimlik doğrulamasını başlatmalıdır.

Kimlik doğrulaması, Güvenlik Desteği Sağlayıcısı (SSPI) kanal sağlayıcısı tarafından işlenir. İstemciye, SslStreamoluştururken bir RemoteCertificateValidationCallback temsilcisi belirterek sunucu sertifikasının doğrulanma durumunu denetleme fırsatı verilir. Sunucu ayrıca bir RemoteCertificateValidationCallback temsilcisi sağlayarak doğrulamayı denetleyebilir. Temsilci tarafından başvuruda bulunan yöntem, uzak tarafın sertifikasını ve sertifikayı doğrularken karşılaşılan SSPI hatalarını içerir. Sunucu bir temsilci belirtirse, sunucunun istemci kimlik doğrulaması isteyip istemediğine bakılmaksızın temsilcinin yönteminin çağrıldığını unutmayın. Sunucu istemci kimlik doğrulaması istemediyse, sunucunun temsilci yöntemi bir null sertifika ve boş bir sertifika hataları dizisi alır.

Sunucu istemci kimlik doğrulaması gerektiriyorsa, istemci kimlik doğrulaması için bir veya daha fazla sertifika belirtmelidir. İstemcinin birden fazla sertifikası varsa, istemci sunucu için doğru sertifikayı seçmek üzere bir LocalCertificateSelectionCallback temsilcisi sağlayabilir. İstemcinin sertifikaları geçerli kullanıcının "My" sertifika deposunda bulunmalıdır. sertifikalar aracılığıyla istemci kimlik doğrulaması, Ssl2 (SSL sürüm 2) protokolü için desteklenmez.

Kimlik doğrulaması başarısız olursa, bir AuthenticationExceptionalırsınız ve SslStream artık kullanılamaz. Bu nesneyi kapatmanız ve çöp toplayıcısı tarafından toplanabilmesi için ona yapılan tüm başvuruları kaldırmanız gerekir.

SSL el sıkışması olarak da bilinen kimlik doğrulama işlemi başarılı olduğunda, sunucunun (ve isteğe bağlı olarak istemcinin) kimliği oluşturulur ve SslStream istemci ve sunucu tarafından ileti alışverişi için kullanılabilir. Bilgi göndermeden veya almadan önce istemci ve sunucu, seçilen protokolün, algoritmaların ve güçlü yönlerin bütünlük ve gizlilik gereksinimlerini karşılayıp karşılamadığını belirlemek için SslStream tarafından sağlanan güvenlik hizmetlerini ve düzeylerini denetlemelidir. Geçerli ayarlar yeterli değilse, akış kapatılmalıdır. IsEncrypted ve IsSigned özelliklerini kullanarak SslStream tarafından sağlanan güvenlik hizmetlerini de kontrol edebilirsiniz. Aşağıdaki tabloda, kimlik doğrulaması, şifreleme ve veri imzalama için kullanılan şifreleme ayarlarını bildiren öğeler gösterilmektedir.

Öğe	Üyeler
Sunucunun ve isteğe bağlı olarak istemcinin kimliğini doğrulamak için kullanılan güvenlik protokolü.	SslProtocol özelliği ve ilişkili SslProtocols numaralandırması.
Anahtar değişimi algoritması.	KeyExchangeAlgorithm özelliği ve ilişkili ExchangeAlgorithmType numaralandırması.
İleti bütünlüğü algoritması.	HashAlgorithm özelliği ve ilişkili HashAlgorithmType numaralandırması.
İleti gizliliği algoritması.	CipherAlgorithm özelliği ve ilişkili CipherAlgorithmType numaralandırması.
Seçilen algoritmaların güçlü yönleri.	KeyExchangeStrength, HashStrengthve CipherStrength özellikleri.

Başarılı bir kimlik doğrulamasından sonra, zaman uyumlu Write veya zaman uyumsuz BeginWrite yöntemlerini kullanarak veri gönderebilirsiniz. Zaman uyumlu Read veya zaman uyumsuz BeginRead yöntemlerini kullanarak veri alabilirsiniz.

temel alınan akışın açık bırakılması gerektiğini SslStream belirttiyseniz, kullanmayı bitirdiğinizde bu akışı kapatmak sizin sorumluluğunuzdadır.

Not

SslStream nesnesini oluşturan uygulama Normal kullanıcının kimlik bilgileriyle çalışıyorsa, kullanıcıya açıkça izin verilmediği sürece uygulama yerel makine deposunda yüklü sertifikalara erişemez.

SslStream, iç akıştan biri atıldığında diğer IOException birlikte zaman aşımının çağıranın önemli olarak kabul edeceği varsayılır. Zaman aşımı sonrasında bir SslStream örneğinin yeniden kullanılmaya başlanması çöp döndürür. Bir uygulamanın SslStreamClose ve bu durumlarda bir özel durum oluşturması gerekir.

.NET Framework 4.6, güvenli olmayan şifreleme ve bağlantılar için karma algoritmaları engelleyen yeni bir güvenlik özelliği içerir. HTTPClient, HttpWebRequest, FTPClient, SmtpClient, SslStream gibi API'ler aracılığıyla TLS/SSL kullanan ve .NET Framework 4.6'yı hedefleyen uygulamalar varsayılan olarak daha güvenli bir davranış elde eder.

Geliştiriciler, mevcut SSL3 hizmetleri veya RC4 w/ RC4 hizmetleriyle birlikte çalışabilirliği sürdürmek için bu davranışı geri çevirmek isteyebilir. Bu makalede, yeni davranışın devre dışı bırakılması için kodunuzun nasıl değiştirileceği açıklanmaktadır.

.NET Framework 4.7, SSLStreams kimliğini doğrulayan ve TLS sürümü belirtmeyen, bunun yerine SCHANNEL'de sistem varsayılanı olarak tanımlanan TLS sürümünü kullanan yöntemler için yeni aşırı yüklemeler ekler. Uygulamanızı yeniden derlemeye ve yeniden dağıtmaya gerek kalmadan, zaman içinde TLS sürümü en iyi yöntem değiştikçe varsayılanları daha sonra değiştirebilmenin bir yolu olarak uygulamanızda bu yöntemleri kullanın.

Ayrıca bkz. .NET Frameworkile Aktarım Katmanı Güvenliği (TLS) en iyi yöntemleri.

Oluşturucular

SslStream(Stream)	Belirtilen Streamkullanarak SslStream sınıfının yeni bir örneğini başlatır.
SslStream(Stream, Boolean)	Belirtilen Stream ve akış kapatma davranışını kullanarak SslStream sınıfının yeni bir örneğini başlatır.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback)	Belirtilen Stream, akış kapatma davranışı ve sertifika doğrulama temsilcisini kullanarak SslStream sınıfının yeni bir örneğini başlatır.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)	Belirtilen Stream, akış kapatma davranışı, sertifika doğrulama temsilcisi ve sertifika seçimi temsilcisini kullanarak SslStream sınıfının yeni bir örneğini başlatır.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)	Belirtilen Streamkullanarak SslStream sınıfının yeni bir örneğini başlatır.

Özellikler

CanRead	Temel alınan akışın okunabilir olup olmadığını gösteren bir Boolean değeri alır.
CanSeek	Temel alınan akışın aranabilir olup olmadığını gösteren bir Boolean değeri alır.
CanTimeout	Temel alınan akışın zaman aşımlarını destekleyip desteklemediğini gösteren bir Boolean değeri alır.
CanWrite	Temel alınan akışın yazılabilir olup olmadığını gösteren bir Boolean değeri alır.
CheckCertRevocationStatus	Sertifika doğrulama işlemi sırasında sertifika iptal listesinin denetlenip denetlenmediğini gösteren bir Boolean değeri alır.
CipherAlgorithm	Bu SslStreamtarafından kullanılan toplu şifreleme algoritmasını tanımlayan bir değer alır.
CipherStrength	Bu SslStreamtarafından kullanılan şifreleme algoritmasının gücünü tanımlayan bir değer alır.
HashAlgorithm	İleti kimlik doğrulama kodları (MAC) oluşturmak için kullanılan algoritmayı alır.
HashStrength	Bu örnek tarafından kullanılan karma algoritmasının gücünü tanımlayan bir değer alır.
InnerStream	Bu AuthenticatedStream tarafından veri göndermek ve almak için kullanılan akışı alır. (Devralındığı yer: AuthenticatedStream)
IsAuthenticated	Kimlik doğrulamasının başarılı olup olmadığını gösteren bir Boolean değeri alır.
IsEncrypted	Bu SslStream veri şifreleme kullanıp kullanmadığını gösteren bir Boolean değeri alır.
IsMutuallyAuthenticated	Hem sunucunun hem de istemcinin kimliğinin doğrulanıp doğrulanmamış olduğunu gösteren bir Boolean değeri alır.
IsServer	Bu SslStream tarafından kullanılan bağlantının yerel tarafının sunucu olarak kimlik doğrulaması yapılıp yapılmadığını gösteren bir Boolean değeri alır.
IsSigned	Bu akış kullanılarak gönderilen verilerin imzalanıp imzalanmadığını gösteren bir Boolean değeri alır.
KeyExchangeAlgorithm	Bu SslStreamtarafından kullanılan anahtar değişimi algoritmasını alır.
KeyExchangeStrength	Bu örnek tarafından kullanılan anahtar değişimi algoritmasının gücünü tanımlayan bir değer alır.
LeaveInnerStreamOpen	Bu AuthenticatedStream tarafından veri göndermek ve almak için kullanılan akışın açık bırakılıp bırakılmadığını alır. (Devralındığı yer: AuthenticatedStream)
Length	Temel alınan akışın uzunluğunu alır.
LocalCertificate	Yerel uç noktanın kimliğini doğrulamak için kullanılan sertifikayı alır.
NegotiatedApplicationProtocol	TLS el sıkışmasında anlaşmaya varılan uygulama protokolü.
NegotiatedCipherSuite	Bu bağlantı için anlaşmaya varılan şifre paketini alır.
Position	Temel alınan akıştaki geçerli konumu alır veya ayarlar.
ReadTimeout	Verileri bekleyen bir okuma işlemi, milisaniye cinsinden ifade edilen süreyi alır veya ayarlar.
RemoteCertificate	Uzak uç noktanın kimliğini doğrulamak için kullanılan sertifikayı alır.
SslProtocol	Bu bağlantının kimliğini doğrulamak için kullanılan güvenlik protokollerini gösteren bir değer alır.
TargetHostName	İstemcinin bağlanmaya çalıştığı sunucunun adını alır. Bu ad, sunucu sertifikası doğrulaması için kullanılır. Dns adı veya IP adresi olabilir.
TransportContext	Genişletilmiş koruma kullanarak kimlik doğrulaması için kullanılan TransportContext alır.
WriteTimeout	Yazma işleminin veri bekleme süresini alır veya ayarlar.

Yöntemler

AuthenticateAsClient(SslClientAuthenticationOptions)	İstemciler tarafından sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini doğrulamak için çağrılır.
AuthenticateAsClient(String)	İstemciler tarafından sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini doğrulamak için çağrılır.
AuthenticateAsClient(String, X509CertificateCollection, Boolean)	İstemciler tarafından sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini doğrulamak için çağrılır. Kimlik doğrulama işlemi, belirtilen sertifika koleksiyonunu ve sistem varsayılan SSL protokollerini kullanır.
AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)	İstemciler tarafından sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini doğrulamak için çağrılır. Kimlik doğrulama işlemi, belirtilen sertifika koleksiyonunu ve SSL protokollerini kullanır.
AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)	İstemciler tarafından sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini zaman uyumsuz bir işlem olarak doğrulamak için çağrılır. Kimlik doğrulama işlemi, sslClientAuthenticationOptions özellik paketinde belirtilen bilgileri kullanır.
AuthenticateAsClientAsync(String)	İstemciler tarafından sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini zaman uyumsuz bir işlem olarak doğrulamak için çağrılır.
AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)	İstemciler tarafından sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini zaman uyumsuz bir işlem olarak doğrulamak için çağrılır. Kimlik doğrulama işlemi, belirtilen sertifika koleksiyonunu ve sistem varsayılan SSL protokolunu kullanır.
AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)	İstemciler tarafından sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini zaman uyumsuz bir işlem olarak doğrulamak için çağrılır. Kimlik doğrulama işlemi, belirtilen sertifika koleksiyonunu ve SSL protokollerini kullanır.
AuthenticateAsServer(SslServerAuthenticationOptions)	Sunucu ve isteğe bağlı olarak belirtilen sertifikayı kullanarak istemci-sunucu bağlantısında istemcinin kimliğini doğrulamak için sunucular tarafından çağrılır.
AuthenticateAsServer(X509Certificate)	Sunucu ve isteğe bağlı olarak belirtilen sertifikayı kullanarak istemci-sunucu bağlantısında istemcinin kimliğini doğrulamak için sunucular tarafından çağrılır.
AuthenticateAsServer(X509Certificate, Boolean, Boolean)	Belirtilen sertifikaları ve gereksinimleri kullanarak ve sistem varsayılan güvenlik protokollerini kullanarak sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini doğrulamak için sunucular tarafından çağrılır.
AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)	Belirtilen sertifikaları, gereksinimleri ve güvenlik protokollerini kullanarak sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini doğrulamak için sunucular tarafından çağrılır.
AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken)	Sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini zaman uyumsuz bir işlem olarak doğrulamak için sunucular tarafından çağrılır. Kimlik doğrulama işlemi, optionsCallbacktarafından döndürülen bilgileri kullanır.
AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)	Sunucunun ve isteğe bağlı olarak istemci-sunucu bağlantısındaki istemcinin kimliğini zaman uyumsuz bir işlem olarak doğrulamak için sunucular tarafından çağrılır. Kimlik doğrulama işlemi, sslClientAuthenticationOptions özellik paketinde belirtilen bilgileri kullanır.
AuthenticateAsServerAsync(X509Certificate)	Sunucu kimliğini doğrulamak için sunucular tarafından çağrılır ve isteğe bağlı olarak istemci-sunucu bağlantısında belirtilen sertifikayı zaman uyumsuz bir işlem olarak kullanarak kullanılır.
AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)	Sunucu kimliğini doğrulamak için sunucular tarafından çağrılır ve isteğe bağlı olarak istemci-sunucu bağlantısında belirtilen sertifikaları, gereksinimleri ve güvenlik protokollerini zaman uyumsuz bir işlem olarak kullanır.
AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)	Sunucu kimliğini doğrulamak için sunucular tarafından çağrılır ve isteğe bağlı olarak istemci-sunucu bağlantısında belirtilen sertifikaları, gereksinimleri ve güvenlik protokollerini zaman uyumsuz bir işlem olarak kullanır.
BeginAuthenticateAsClient(String, AsyncCallback, Object)	Sunucunun ve isteğe bağlı olarak istemcinin kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için istemciler tarafından çağrılır.
BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)	İstemciler tarafından, belirtilen sertifikaları ve sistem varsayılan güvenlik protokollerini kullanarak sunucunun ve isteğe bağlı olarak istemcinin kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak üzere çağrılır.
BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)	İstemciler tarafından, sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için ve isteğe bağlı olarak belirtilen sertifikaları ve güvenlik protokollerini kullanarak istemci tarafından çağrılır.
BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)	İstemcinin ve isteğe bağlı olarak istemci-sunucu bağlantısında sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için sunucular tarafından çağrılır.
BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)	Sunucu kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için sunucular tarafından çağrılır ve isteğe bağlı olarak belirtilen sertifikalar ve gereksinimleri ve sistem varsayılan güvenlik protokolü kullanılarak istemci.
BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)	Sunucu ve isteğe bağlı olarak belirtilen sertifikaları, gereksinimleri ve güvenlik protokollerini kullanarak istemcinin kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için sunucular tarafından çağrılır.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Akıştaki verileri okuyan ve belirtilen dizide depolayan zaman uyumsuz bir okuma işlemi başlatır.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Belirtilen arabellekten akışa Byteyazan zaman uyumsuz bir yazma işlemi başlatır.
Close()	Geçerli akışı kapatır ve geçerli akışla ilişkili tüm kaynakları (yuvalar ve dosya tanıtıcıları gibi) serbest bırakır. Bu yöntemi çağırmak yerine akışın düzgün şekilde atıldığından emin olun. (Devralındığı yer: Stream)
CopyTo(Stream)	Geçerli akıştan baytları okur ve başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyTo(Stream, Int32)	Geçerli akıştan baytları okur ve belirtilen arabellek boyutunu kullanarak başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream)	Geçerli akıştan gelen baytları zaman uyumsuz olarak okur ve başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream, CancellationToken)	Geçerli akıştan gelen baytları zaman uyumsuz olarak okur ve belirtilen iptal belirtecini kullanarak başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream, Int32)	Geçerli akıştan gelen baytları zaman uyumsuz olarak okur ve belirtilen arabellek boyutunu kullanarak başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Belirtilen arabellek boyutu ve iptal belirtecini kullanarak geçerli akıştan baytları zaman uyumsuz olarak okur ve başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CreateObjRef(Type)	Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
CreateWaitHandle()	Geçersiz. bir WaitHandle nesnesi ayırır. (Devralındığı yer: Stream)
Dispose()	Streamtarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: Stream)
Dispose(Boolean)	SslStream tarafından kullanılan yönetilmeyen kaynakları serbest bırakır ve isteğe bağlı olarak yönetilen kaynakları serbest bırakır.
DisposeAsync()	SslStreamtarafından kullanılan yönetilmeyen ve yönetilen kaynakları zaman uyumsuz olarak serbest bırakır.
EndAuthenticateAsClient(IAsyncResult)	BeginAuthenticateAsClientönceki bir çağrıyla başlatılan bekleyen zaman uyumsuz sunucu kimlik doğrulama işlemini sonlandırır.
EndAuthenticateAsServer(IAsyncResult)	BeginAuthenticateAsClientönceki bir çağrıyla başlatılan bekleyen zaman uyumsuz istemci kimlik doğrulama işlemini sonlandırır.
EndRead(IAsyncResult)	BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)önceki bir çağrıyla başlatılan zaman uyumsuz okuma işlemini sonlandırır.
EndWrite(IAsyncResult)	BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)önceki bir çağrıyla başlatılan zaman uyumsuz yazma işlemini sonlandırır.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
Finalize()	SslStreamtarafından kullanılan tüm kaynakları serbest bırakır.
Flush()	Arabelleğe alınan verilerin temel alınan cihaza yazılması neden olur.
FlushAsync()	Bu akış için tüm arabellekleri zaman uyumsuz olarak temizler ve arabelleğe alınan verilerin temel alınan cihaza yazılmasına neden olur. (Devralındığı yer: Stream)
FlushAsync(CancellationToken)	Arabelleğe alınan tüm verileri zaman uyumsuz olarak temel alınan cihaza yazar.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Geçersiz. Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
InitializeLifetimeService()	Geçersiz. Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnesinin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)	Kimliği doğrulanmış bağlantıda istemci sertifikasıyla anlaşma yapar.
ObjectInvariant()	Geçersiz. Contractiçin destek sağlar. (Devralındığı yer: Stream)
Read(Byte[], Int32, Int32)	Bu akıştaki verileri okur ve belirtilen dizide depolar.
Read(Span<Byte>)	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli akıştan bir bayt dizisi okur ve okunan bayt sayısına göre akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadAsync(Byte[], Int32, Int32)	Geçerli akıştan zaman uyumsuz olarak bir bayt dizisi okur ve okunan bayt sayısına göre akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Bu akıştaki verileri zaman uyumsuz olarak okur ve belirtilen bayt dizisi aralığında depolar.
ReadAsync(Memory<Byte>, CancellationToken)	Bu akıştaki verileri zaman uyumsuz olarak okur ve belirtilen bellek aralığında depolar.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Geçerli akıştan en az bayt sayısını okur ve okunan bayt sayısına göre akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Geçerli akıştan en az en az sayıda bayt zaman uyumsuz olarak okur, okunan bayt sayısına göre akıştaki konumu ilerletir ve iptal isteklerini izler. (Devralındığı yer: Stream)
ReadByte()	SslStream bir bayt okur ve akışın içindeki konumu bir bayt ilerletir veya akışın sonundaysa -1 döndürür.
ReadExactly(Byte[], Int32, Int32)	Geçerli akıştan count bayt sayısını okur ve akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadExactly(Span<Byte>)	Geçerli akıştan baytları okur ve buffer doldurulana kadar akıştaki konumu ilerletir. (Devralındığı yer: Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Geçerli akıştan count bayt sayısını zaman uyumsuz olarak okur, akış içindeki konumu ilerletir ve iptal isteklerini izler. (Devralındığı yer: Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Geçerli akıştaki baytları zaman uyumsuz olarak okur, buffer doldurulana kadar akıştaki konumu ilerletir ve iptal isteklerini izler. (Devralındığı yer: Stream)
Seek(Int64, SeekOrigin)	bir NotSupportedExceptionoluşturur.
SetLength(Int64)	Temel alınan akışın uzunluğunu ayarlar.
ShutdownAsync()	Bu SslStream'i kapatır.
ToString()	Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object)
Write(Byte[])	Belirtilen verileri bu akışa yazar.
Write(Byte[], Int32, Int32)	Belirtilen arabellek ve uzaklığı kullanarak temel alınan akışa belirtilen sayıda Byteyazın.
Write(ReadOnlySpan<Byte>)	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli akışa bir bayt dizisi yazar ve yazılan bayt sayısıyla bu akıştaki geçerli konumu ilerletir. (Devralındığı yer: Stream)
WriteAsync(Byte[], Int32, Int32)	Zaman uyumsuz olarak geçerli akışa bir bayt dizisi yazar ve bu akıştaki geçerli konumu yazılan bayt sayısına göre ilerletir. (Devralındığı yer: Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Belirtilen bayt dizisi aralığından temel alınan akışa zaman uyumsuz olarak veri yazar.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Verileri, salt okunur bayt bellek aralığından temel alınan akışa zaman uyumsuz olarak yazar.
WriteByte(Byte)	Akıştaki geçerli konuma bir bayt yazar ve akış içindeki konumu bir bayt ilerletir. (Devralındığı yer: Stream)

Uzantı Metotları

CopyToAsync(Stream, PipeWriter, CancellationToken)	Stream baytları zaman uyumsuz olarak okur ve bir iptal belirteci kullanarak belirtilen PipeWriteryazar.
ConfigureAwait(IAsyncDisposable, Boolean)	Zaman uyumsuz bir atılabilir öğeden döndürülen görevlerde awaits işleminin nasıl gerçekleştirileceğini yapılandırılır.

Ayrıca bkz.

• NegotiateStream
• AuthenticatedStream
• IOException
• Stream