SslStream Sınıf

Tanım

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
type SslStream = class
    inherit AuthenticatedStream
    interface IDisposable
Public Class SslStream
Inherits AuthenticatedStream
Devralma
Devralma
Uygulamalar

Örnekler

Aşağıdaki kod örneği, istemcilerle iletişim kurmak için sınıfını kullanan bir TcpListener oluşturma işlemini SslStream 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,8080 );
      listener->Start();
      
      while (true) 
      {
         Console::WriteLine( L"Waiting for a client to connect..." );
         
         // Application blocks while waiting for an incoming connection.
         // Type CNTL-C to terminate the server.
         TcpClient^ client = listener->AcceptTcpClient();
         ProcessClient( client );

      }
   }


   static void ProcessClient( TcpClient^ client )
   {
      
      // A client has connected. Create the 
      // SslStream using the client's network stream.
      SslStream^ sslStream = gcnew SslStream( client->GetStream(),false );
      
      // Authenticate the server but don't require the client to authenticate.
      try
      {
         sslStream->AuthenticateAsServer( serverCertificate, false, true );
         // false == no client cert required; true == check cert revocation.
         
         // Display the properties and settings for the authenticated stream.
         DisplaySecurityLevel( sslStream );
         DisplaySecurityServices( sslStream );
         DisplayCertificateInformation( sslStream );
         DisplayStreamProperties( sslStream );
         
         // Set timeouts for the read and write to 5 seconds.
         sslStream->ReadTimeout = 5000;
         sslStream->WriteTimeout = 5000;
         
         // Read a message from the client.   
         Console::WriteLine( L"Waiting for client message..." );
         String^ messageData = ReadMessage( sslStream );
         Console::WriteLine( L"Received: {0}", messageData );
         
         // Write a message to the client.
         array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the server.<EOF>" );
         Console::WriteLine( L"Sending hello message." );
         sslStream->Write( message );
      }
      catch ( AuthenticationException^ e ) 
      {
         Console::WriteLine( L"Exception: {0}", e->Message );
         if ( e->InnerException != nullptr )
         {
            Console::WriteLine( L"Inner exception: {0}", e->InnerException->Message );
         }
         Console::WriteLine( L"Authentication failed - closing the connection." );
         sslStream->Close();
         client->Close();
         return;
      }
      finally
      {
         
         // The client stream will be closed with the sslStream
         // because we specified this behavior when creating
         // the sslStream.
         sslStream->Close();
         client->Close();
      }

   }


   static String^ ReadMessage( SslStream^ sslStream )
   {
      
      // Read the  message sent by the client.
      // The client signals the end of the message using the
      // "<EOF>" marker.
      array<Byte>^buffer = gcnew array<Byte>(2048);
      StringBuilder^ messageData = gcnew StringBuilder;
      int bytes = -1;
      do
      {
         
         // Read the client's test message.
         bytes = sslStream->Read( buffer, 0, buffer->Length );
         
         // Use Decoder class to convert from bytes to UTF8
         // in case a character spans two buffers.
         Decoder^ decoder = Encoding::UTF8->GetDecoder();
         array<Char>^chars = gcnew array<Char>(decoder->GetCharCount( buffer, 0, bytes ));
         decoder->GetChars( buffer, 0, bytes, chars, 0 );
         messageData->Append( chars );
         
         // Check for EOF or an empty message.
         if ( messageData->ToString()->IndexOf( L"<EOF>" ) != -1 )
         {
            break;
         }
      }
      while ( bytes != 0 );

      return messageData->ToString();
   }


   static void DisplaySecurityLevel( SslStream^ stream )
   {
      Console::WriteLine( L"Cipher: {0} strength {1}", stream->CipherAlgorithm, stream->CipherStrength );
      Console::WriteLine( L"Hash: {0} strength {1}", stream->HashAlgorithm, stream->HashStrength );
      Console::WriteLine( L"Key exchange: {0} strength {1}", stream->KeyExchangeAlgorithm, stream->KeyExchangeStrength );
      Console::WriteLine( L"Protocol: {0}", stream->SslProtocol );
   }


   static void DisplaySecurityServices( SslStream^ stream )
   {
      Console::WriteLine( L"Is authenticated: {0} as server? {1}", stream->IsAuthenticated, stream->IsServer );
      Console::WriteLine( L"IsSigned: {0}", stream->IsSigned );
      Console::WriteLine( L"Is Encrypted: {0}", stream->IsEncrypted );
   }


   static void DisplayStreamProperties( SslStream^ stream )
   {
      Console::WriteLine( L"Can read: {0}, write {1}", stream->CanRead, stream->CanWrite );
      Console::WriteLine( L"Can timeout: {0}", stream->CanTimeout );
   }


   static void DisplayCertificateInformation( SslStream^ stream )
   {
      Console::WriteLine( L"Certificate revocation list checked: {0}", stream->CheckCertRevocationStatus );
      X509Certificate^ localCertificate = stream->LocalCertificate;
      if ( stream->LocalCertificate != nullptr )
      {
         Console::WriteLine( L"Local cert was issued to {0} and is valid from {1} until {2}.", 
             localCertificate->Subject, 
             localCertificate->GetEffectiveDateString(), 
             localCertificate->GetExpirationDateString() );
      }
      else
      {
         Console::WriteLine( L"Local certificate is null." );
      }

      X509Certificate^ remoteCertificate = stream->RemoteCertificate;
      if ( stream->RemoteCertificate != nullptr )
      {
         Console::WriteLine( L"Remote cert was issued to {0} and is valid from {1} until {2}.", 
            remoteCertificate->Subject, 
            remoteCertificate->GetEffectiveDateString(), 
            remoteCertificate->GetExpirationDateString() );
      }
      else
      {
         Console::WriteLine( L"Remote certificate is null." );
      }
   }


private:

   static void DisplayUsage()
   {
      Console::WriteLine( L"To start the server specify:" );
      Console::WriteLine( L"serverSync certificateFile.cer" );
      Environment::Exit( 1 );
   }

public:
   int RunServerASync()
   {
      array<String^>^args = Environment::GetCommandLineArgs();
      String^ certificate = nullptr;
      if ( args == nullptr || args->Length < 2 )
      {
         DisplayUsage();
      }

      certificate = args[ 1 ];
      SslTcpServer::RunServer( certificate );
      return 0;
   }

};

int main(){
    SslTcpServer^ sts = gcnew SslTcpServer();
    sts->RunServerASync();
}
using System;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.IO;

namespace Examples.System.Net
{
    public sealed class SslTcpServer
    {
        static X509Certificate serverCertificate = null;
        // The certificate parameter specifies the name of the file
        // containing the machine certificate.
        public static void RunServer(string certificate)
        {
            serverCertificate = X509Certificate.CreateFromCertFile(certificate);
            // Create a TCP/IP (IPv4) socket and listen for incoming connections.
            TcpListener listener = new TcpListener(IPAddress.Any, 8080);
            listener.Start();
            while (true)
            {
                Console.WriteLine("Waiting for a client to connect...");
                // Application blocks while waiting for an incoming connection.
                // Type CNTL-C to terminate the server.
                TcpClient client = listener.AcceptTcpClient();
                ProcessClient(client);
            }
        }
        static void ProcessClient (TcpClient client)
        {
            // A client has connected. Create the
            // SslStream using the client's network stream.
            SslStream sslStream = new SslStream(
                client.GetStream(), false);
            // Authenticate the server but don't require the client to authenticate.
            try
            {
                sslStream.AuthenticateAsServer(serverCertificate, clientCertificateRequired: false, checkCertificateRevocation: true);

                // Display the properties and settings for the authenticated stream.
                DisplaySecurityLevel(sslStream);
                DisplaySecurityServices(sslStream);
                DisplayCertificateInformation(sslStream);
                DisplayStreamProperties(sslStream);

                // Set timeouts for the read and write to 5 seconds.
                sslStream.ReadTimeout = 5000;
                sslStream.WriteTimeout = 5000;
                // Read a message from the client.
                Console.WriteLine("Waiting for client message...");
                string messageData = ReadMessage(sslStream);
                Console.WriteLine("Received: {0}", messageData);

                // Write a message to the client.
                byte[] message = Encoding.UTF8.GetBytes("Hello from the server.<EOF>");
                Console.WriteLine("Sending hello message.");
                sslStream.Write(message);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine ("Authentication failed - closing the connection.");
                sslStream.Close();
                client.Close();
                return;
            }
            finally
            {
                // The client stream will be closed with the sslStream
                // because we specified this behavior when creating
                // the sslStream.
                sslStream.Close();
                client.Close();
            }
        }
        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the client.
            // The client signals the end of the message using the
            // "<EOF>" marker.
            byte [] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                // Read the client's test message.
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
                decoder.GetChars(buffer, 0, bytes, chars,0);
                messageData.Append (chars);
                // Check for EOF or an empty message.
                if (messageData.ToString().IndexOf("<EOF>") != -1)
                {
                    break;
                }
            } while (bytes !=0);

            return messageData.ToString();
        }
         static void DisplaySecurityLevel(SslStream stream)
         {
            Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength);
            Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength);
            Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength);
            Console.WriteLine("Protocol: {0}", stream.SslProtocol);
         }
         static void DisplaySecurityServices(SslStream stream)
         {
            Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer);
            Console.WriteLine("IsSigned: {0}", stream.IsSigned);
            Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted);
         }
         static void DisplayStreamProperties(SslStream stream)
         {
            Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite);
            Console.WriteLine("Can timeout: {0}", stream.CanTimeout);
         }
        static void DisplayCertificateInformation(SslStream stream)
        {
            Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus);

            X509Certificate localCertificate = stream.LocalCertificate;
            if (stream.LocalCertificate != null)
            {
                Console.WriteLine("Local cert was issued to {0} and is valid from {1} until {2}.",
                    localCertificate.Subject,
                    localCertificate.GetEffectiveDateString(),
                    localCertificate.GetExpirationDateString());
             } else
            {
                Console.WriteLine("Local certificate is null.");
            }
            // Display the properties of the client's certificate.
            X509Certificate remoteCertificate = stream.RemoteCertificate;
            if (stream.RemoteCertificate != null)
            {
            Console.WriteLine("Remote cert was issued to {0} and is valid from {1} until {2}.",
                remoteCertificate.Subject,
                remoteCertificate.GetEffectiveDateString(),
                remoteCertificate.GetExpirationDateString());
            } else
            {
                Console.WriteLine("Remote certificate is null.");
            }
        }
        private static void DisplayUsage()
        {
            Console.WriteLine("To start the server specify:");
            Console.WriteLine("serverSync certificateFile.cer");
            Environment.Exit(1);
        }
        public static int Main(string[] args)
        {
            string certificate = null;
            if (args == null ||args.Length < 1 )
            {
                DisplayUsage();
            }
            certificate = args[0];
            SslTcpServer.RunServer (certificate);
            return 0;
        }
    }
}
Imports System.Collections
Imports System.Net
Imports System.Net.Sockets
Imports System.Net.Security
Imports System.Security.Authentication
Imports System.Text
Imports System.Security.Cryptography.X509Certificates
Imports System.IO

Namespace Examples.System.Net
    Public NotInheritable Class SslTcpServer
        Shared serverCertificate As X509Certificate = Nothing

        ' The certificate parameter specifies the name of the file 
        ' containing the machine certificate.
        Public Shared Sub RunServer(certificate As String)
            serverCertificate = X509Certificate.CreateFromCertFile(certificate)
            ' Create a TCP/IP (IPv4) socket And listen for incoming connections.
            Dim listener = New TcpListener(IPAddress.Any, 8080)
            listener.Start()

            While True
                Console.WriteLine("Waiting for a client to connect...")
                ' Application blocks while waiting for an incoming connection.
                ' Type CNTL-C to terminate the server.
                Dim client As TcpClient = listener.AcceptTcpClient()
                ProcessClient(client)
            End While
        End Sub
        Private Shared Sub ProcessClient(client As TcpClient)
            ' A client has connected. Create the 
            ' SslStream using the client's network stream.
            Dim sslStream = New SslStream(client.GetStream(), False)

            Try

                sslStream.AuthenticateAsServer(serverCertificate, clientCertificateRequired:=False, checkCertificateRevocation:=True)
                ' Display the properties And settings for the authenticated stream.
                DisplaySecurityLevel(sslStream)
                DisplaySecurityServices(sslStream)
                DisplayCertificateInformation(sslStream)
                DisplayStreamProperties(sslStream)

                ' Set timeouts for the read and write to 5 seconds.
                sslStream.ReadTimeout = 5000
                sslStream.WriteTimeout = 5000

                ' Read a message from the client.   
                Console.WriteLine("Waiting for client message...")
                Dim messageData As String = ReadMessage(sslStream)
                Console.WriteLine("Received: {0}", messageData)

                ' Write a message to the client.
                Dim message As Byte() = Encoding.UTF8.GetBytes("Hello from the server.<EOF>")
                Console.WriteLine("Sending hello message.")
                sslStream.Write(message)
            Catch e As AuthenticationException
                Console.WriteLine("Exception: {0}", e.Message)

                If e.InnerException IsNot Nothing Then
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message)
                End If

                Console.WriteLine("Authentication failed - closing the connection.")
                sslStream.Close()
                client.Close()
                Return
            Finally
                ' The client stream will be closed with the sslStream
                ' because we specified this behavior when creating
                ' the sslStream.
                sslStream.Close()
                client.Close()
            End Try
        End Sub

        Private Shared Function ReadMessage(sslStream As SslStream) As String

            ' Read the  message sent by the client.
            ' The client signals the end of the message using the
            ' "<EOF>" marker.
            Dim buffer As Byte() = New Byte(2048) {}
            Dim messageData As StringBuilder = New StringBuilder()
            Dim bytes As Integer = -1

            Do
                ' Read the client's test message.
                bytes = sslStream.Read(buffer, 0, buffer.Length)

                ' Use decoder class to convert from bytes to UTF8
                ' in case a character spans two buffers.
                Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
                Dim chars As Char() = New Char(decoder.GetCharCount(buffer, 0, bytes) - 1) {}
                decoder.GetChars(buffer, 0, bytes, chars, 0)
                messageData.Append(chars)

                ' Check for EOF or an empty message.
                If messageData.ToString().IndexOf("<EOF>") <> -1 Then
                    Exit Do
                End If
            Loop While bytes <> 0

            Return messageData.ToString()
        End Function

        Private Shared Sub DisplaySecurityLevel(stream As SslStream)
            Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength)
            Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength)
            Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength)
            Console.WriteLine("Protocol: {0}", stream.SslProtocol)
        End Sub

        Private Shared Sub DisplaySecurityServices(stream As SslStream)
            Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer)
            Console.WriteLine("IsSigned: {0}", stream.IsSigned)
            Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted)
        End Sub

        Private Shared Sub DisplayStreamProperties(stream As SslStream)
            Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite)
            Console.WriteLine("Can timeout: {0}", stream.CanTimeout)
        End Sub

        Private Shared Sub DisplayCertificateInformation(stream As SslStream)
            Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus)
            Dim localCertificate As X509Certificate = stream.LocalCertificate

            If stream.LocalCertificate IsNot Nothing Then
                Console.WriteLine("Local cert was issued to {0} and is valid from {1} until {2}.", localCertificate.Subject, localCertificate.GetEffectiveDateString(), localCertificate.GetExpirationDateString())
            Else
                Console.WriteLine("Local certificate is null.")
            End If

            ' Display the properties of the client's certificate.
            Dim remoteCertificate As X509Certificate = stream.RemoteCertificate

            If stream.RemoteCertificate IsNot Nothing Then
                Console.WriteLine("Remote cert was issued to {0} and is valid from {1} until {2}.", remoteCertificate.Subject, remoteCertificate.GetEffectiveDateString(), remoteCertificate.GetExpirationDateString())
            Else
                Console.WriteLine("Remote certificate is null.")
            End If
        End Sub

        Private Shared Sub DisplayUsage()
            Console.WriteLine("To start the server specify:")
            Console.WriteLine("serverSync certificateFile.cer")
            Environment.[Exit](1)
        End Sub

        Public Shared Function Main(ByVal args As String()) As Integer
            Dim certificate As String

            If args Is Nothing OrElse args.Length < 1 Then
                DisplayUsage()
            End If

            certificate = args(0)
            RunServer(certificate)
            Return 0
        End Function
    End Class
End Namespace

Aşağıdaki kod örneği, bir sunucuyla iletişim kurmak için sınıfını SslStream 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, 8080);
            Console::WriteLine("Client connected.");
              
            // Create an SSL stream that will close 
            // the client's stream.
            SslStream^ sslStream = gcnew SslStream(
                client->GetStream(), false,
                gcnew RemoteCertificateValidationCallback(ValidateServerCertificate),
                nullptr);
              
            // The server name must match the name
            // on the server certificate.
            try
            {
                sslStream->AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException^ ex) 
            {
                Console::WriteLine("Exception: {0}", ex->Message);
                if (ex->InnerException != nullptr)
                {
                    Console::WriteLine("Inner exception: {0}", 
                        ex->InnerException->Message);
                }

                Console::WriteLine("Authentication failed - "
                    "closing the connection.");
                sslStream->Close();
                client->Close();
                return;
            }
            // Encode a test message into a byte array.
            // Signal the end of the message using the "<EOF>".
            array<Byte>^ messsage = Encoding::UTF8->GetBytes(
                "Hello from the client.<EOF>");
              
            // Send hello message to the server.
            sslStream->Write(messsage);
            sslStream->Flush();
            // Read message from the server.
            String^ serverMessage = ReadMessage(sslStream);
            Console::WriteLine("Server says: {0}", serverMessage);
           
            // Close the client connection.
            sslStream->Close();
            client->Close();
            Console::WriteLine("Client closed.");
        }
    private:
        static String^ ReadMessage(SslStream^ sslStream)
        {
              
            // Read the  message sent by the server.
            // The end of the message is signaled using the
            // "<EOF>" marker.
            array<Byte>^ buffer = gcnew array<Byte>(2048);
            StringBuilder^ messageData = gcnew StringBuilder;
            // Use Decoder class to convert from bytes to UTF8
            // in case a character spans two buffers.
            Encoding^ u8 = Encoding::UTF8;
            Decoder^ decoder = u8->GetDecoder();

            int bytes = -1;
            do
            {
                bytes = sslStream->Read(buffer, 0, buffer->Length);
                 
                array<__wchar_t>^ chars = gcnew array<__wchar_t>(
                    decoder->GetCharCount(buffer, 0, bytes));
                decoder->GetChars(buffer, 0, bytes, chars, 0);
                messageData->Append(chars);
                 
                // Check for EOF.
                if (messageData->ToString()->IndexOf("<EOF>") != -1)
                {
                    break;
                }
            }
            while (bytes != 0);

            return messageData->ToString();
        }
    };
}

int main()
{
    array<String^>^ args = Environment::GetCommandLineArgs();
    String^ serverCertificateName = nullptr;
    String^ machineName = nullptr;
    if (args == nullptr || args->Length < 2)
    {
        Console::WriteLine("To start the client specify:");
        Console::WriteLine("clientSync machineName [serverName]");
        return 1;
    }
        
    // User can specify the machine name and server name.
    // Server name must match the name on 
    // the server's certificate.
    machineName = args[1];
    if (args->Length < 3)
    {
        serverCertificateName = machineName;
    }
    else
    {
        serverCertificateName = args[2];
    };

    NlsClientSync::SslTcpClient::RunClient(machineName,
        serverCertificateName);

    return 0;
}
using System;
using System.Collections;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.IO;

namespace Examples.System.Net
{
    public class SslTcpClient
    {
        private static Hashtable certificateErrors = new Hashtable();

        // The following method is invoked by the RemoteCertificateValidationDelegate.
        public static bool ValidateServerCertificate(
              object sender,
              X509Certificate certificate,
              X509Chain chain,
              SslPolicyErrors sslPolicyErrors)
        {
           if (sslPolicyErrors == SslPolicyErrors.None)
                return true;

            Console.WriteLine("Certificate error: {0}", sslPolicyErrors);

            // Do not allow this client to communicate with unauthenticated servers.
            return false;
        }
        public static void RunClient(string machineName, string serverName)
        {
            // Create a TCP/IP client socket.
            // machineName is the host running the server application.
            TcpClient client = new TcpClient(machineName,443);
            Console.WriteLine("Client connected.");
            // Create an SSL stream that will close the client's stream.
            SslStream sslStream = new SslStream(
                client.GetStream(),
                false,
                new RemoteCertificateValidationCallback (ValidateServerCertificate),
                null
                );
            // The server name must match the name on the server certificate.
            try
            {
                sslStream.AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine ("Authentication failed - closing the connection.");
                client.Close();
                return;
            }
            // Encode a test message into a byte array.
            // Signal the end of the message using the "<EOF>".
            byte[] messsage = Encoding.UTF8.GetBytes("Hello from the client.<EOF>");
            // Send hello message to the server.
            sslStream.Write(messsage);
            sslStream.Flush();
            // Read message from the server.
            string serverMessage = ReadMessage(sslStream);
            Console.WriteLine("Server says: {0}", serverMessage);
            // Close the client connection.
            client.Close();
            Console.WriteLine("Client closed.");
        }
        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the server.
            // The end of the message is signaled using the
            // "<EOF>" marker.
            byte [] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
                decoder.GetChars(buffer, 0, bytes, chars,0);
                messageData.Append (chars);
                // Check for EOF.
                if (messageData.ToString().IndexOf("<EOF>") != -1)
                {
                    break;
                }
            } while (bytes != 0);

            return messageData.ToString();
        }
        private static void DisplayUsage()
        {
            Console.WriteLine("To start the client specify:");
            Console.WriteLine("clientSync machineName [serverName]");
            Environment.Exit(1);
        }
        public static int Main(string[] args)
        {
            string serverCertificateName = null;
            string machineName = null;
            if (args == null ||args.Length <1 )
            {
                DisplayUsage();
            }
            // User can specify the machine name and server name.
            // Server name must match the name on the server's certificate.
            machineName = args[0];
            if (args.Length <2 )
            {
                serverCertificateName = machineName;
            }
            else
            {
                serverCertificateName = args[1];
            }
            SslTcpClient.RunClient (machineName, serverCertificateName);
            return 0;
        }
    }
}
Imports System.Collections
Imports System.Net
Imports System.Net.Security
Imports System.Net.Sockets
Imports System.Security.Authentication
Imports System.Text
Imports System.Security.Cryptography.X509Certificates
Imports System.IO

Namespace Examples.System.Net

    Public Class SslTcpClient
        
        ' The following method is invoked by the RemoteCertificateValidationDelegate.
        Public Shared Function ValidateServerCertificate(
            sender As Object, 
            certificate As X509Certificate, 
            chain As X509Chain, 
            sslPolicyErrors As SslPolicyErrors) As Boolean
            
            If sslPolicyErrors = SslPolicyErrors.None Then Return True

            Console.WriteLine("Certificate error: {0}", sslPolicyErrors)

            ' Do not allow this client to communicate with unauthenticated servers.
            Return False
        End Function
        Public Shared Sub RunClient(machineName As String, serverName As String)

            ' Create a TCP/IP client socket.
            ' machineName is the host running the server application.
            Dim client = New TcpClient(machineName, 443)
            Console.WriteLine("Client connected.")

            ' Create an SSL stream that will close the client's stream.
            Dim sslStream = New SslStream(
                client.GetStream(), False, 
                New RemoteCertificateValidationCallback(AddressOf ValidateServerCertificate), Nothing)

            ' The server name must match the name on the server certificate.
            Try
                sslStream.AuthenticateAsClient(serverName)
            Catch e As AuthenticationException
                Console.WriteLine("Exception: {0}", e.Message)

                If e.InnerException IsNot Nothing Then
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message)
                End If

                Console.WriteLine("Authentication failed - closing the connection.")
                client.Close()
                Return
            End Try
            
            ' Encode a test message into a byte array.
            ' Signal the end of the message using the "<EOF>".
            Dim messsage As Byte() = Encoding.UTF8.GetBytes("Hello from the client.<EOF>")
            
            ' Send hello message to the server.
            sslStream.Write(messsage)
            sslStream.Flush()
            ' Read message from the server.
            Dim serverMessage = ReadMessage(sslStream)
            Console.WriteLine("Server says: {0}", serverMessage)

            ' Close the client connection
            client.Close()
            Console.WriteLine("Client closed.")
        End Sub
        
        Private Shared Function ReadMessage(sslStream As SslStream) As String

            ' Read the  message sent by the server.
            ' The end of the message is signaled using the "<EOF>" marker.
            Dim buffer = New Byte(2048) {}
            Dim messageData = New StringBuilder()
            Dim bytes As Integer

            Do
                bytes = sslStream.Read(buffer, 0, buffer.Length)

                ' Use Decoder class to convert from bytes to UTF8
                ' in case a character spans two buffers.        
                Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
                Dim chars = New Char(decoder.GetCharCount(buffer, 0, bytes) - 1) {}
                decoder.GetChars(buffer, 0, bytes, chars, 0)
                messageData.Append(chars)

                ' Check for EOF.
                If messageData.ToString().IndexOf("<EOF>") <> -1 Then Exit Do
                
            Loop While bytes <> 0

            Return messageData.ToString()

        End Function

        Private Shared Sub DisplayUsage()

            Console.WriteLine("To start the client specify:")
            Console.WriteLine("clientSync machineName [serverName]")
            Environment.[Exit](1)

        End Sub

        Public Shared Function Main(args As String()) As Integer

            Dim serverCertificateName As String
            Dim machineName As String

            If args Is Nothing OrElse args.Length < 1 Then
                DisplayUsage()
            End If

            ' User can specify the machine name and server name.
            ' Server name must match the name on the server's certificate. 
            machineName = args(0)

            If args.Length < 2 Then
                serverCertificateName = machineName
            Else
                serverCertificateName = args(1)
            End If

            SslTcpClient.RunClient(machineName, serverCertificateName)

            Return 0

        End Function

    End Class

End Namespace

Açıklamalar

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

Bir SslStream örnek, oluştururken SslStreamsağladığınız bir akışı kullanarak veri aktarır. Bu temel akışı sağladığınızda, kapatmanın da temel akışı kapatıp kapatmayacağını SslStream belirtme seçeneğiniz vardır. Genellikle sınıfı SslStream ve TcpListener sınıflarıyla birlikte TcpClient kullanılır. GetStream yöntemi, sınıfıyla SslStream kullanıma uygun bir NetworkStream yöntem sağlar.

bir 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ı, bir SslStreamkullanılarak bilgi aktarılmadan önce gerçekleştirilmelidir. İstemciler, kimlik doğrulaması tamamlanana kadar engelleyen zaman uyumlu AuthenticateAsClient yöntemleri veya kimlik doğrulamasının tamamlanmasını beklemeyi engellemeyen zaman uyumsuz BeginAuthenticateAsClient yöntemleri kullanarak kimlik doğrulamasını başlatır. Sunucular zaman uyumlu AuthenticateAsServer veya zaman uyumsuz BeginAuthenticateAsServer yöntemleri 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 Destek Sağlayıcısı (SSPI) kanal sağlayıcısı tarafından işlenir. İstemciye, oluştururken SslStreambir RemoteCertificateValidationCallback temsilci belirterek sunucu sertifikasının doğrulamasını denetleme fırsatı verilir. Sunucu, temsilci RemoteCertificateValidationCallback sağlayarak doğrulamayı da denetleyebiliyor. Temsilci tarafından başvuruda bulunan yöntem, uzak tarafın sertifikasını ve sertifika doğrulanırken 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 boş bir 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 temsilci sağlayabilir. İstemcinin sertifikaları geçerli kullanıcının "My" sertifika deposunda bulunmalıdır. Sertifikalar aracılığıyla istemci kimlik doğrulaması (SSL sürüm 2) protokolü için Ssl2 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 atık toplayıcı 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 tarafından sağlanan SslStream güvenlik hizmetlerini ve düzeylerini denetleyerek seçilen protokolün, algoritmaların ve güçlü yönlerin bütünlük ve gizlilik gereksinimlerini karşılayıp karşılamadığını belirlemelidir. Geçerli ayarlar yeterli değilse akış kapatılmalıdır. ve IsSigned özelliklerini kullanarak IsEncrypted tarafından SslStream 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 sabit listesi.
Anahtar değişim algoritması. KeyExchangeAlgorithm özelliği ve ilişkili ExchangeAlgorithmType sabit listesi.
İleti bütünlüğü algoritması. HashAlgorithm özelliği ve ilişkili HashAlgorithmType sabit listesi.
İleti gizliliği algoritması. CipherAlgorithm özelliği ve ilişkili CipherAlgorithmType sabit listesi.
Seçilen algoritmaların güçlü yanları. KeyExchangeStrength, HashStrengthve CipherStrength özellikleri.

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

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

Not

Nesneyi oluşturan SslStream uygulama Normal bir 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ğerleriyle IOException birlikte bir zaman aşımının çağıranın önemli olarak ele alınacağını varsayar. Zaman aşımı sonrasında bir SslStream örneği yeniden kullanarak çöp döndürülecektir. Bir uygulama ve bu durumlarda bir özel durum oluşturmalıdır Close SslStream .

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

Geliştiriciler, mevcut SSL3 hizmetleriyle veya RC4 hizmetleriyle TLS ile 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çıklanır.

.NET Framework 4.7, SSLStreams'in kimliğini doğrulayan ve TLS sürümünü 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, tls sürümü en iyi uygulama zaman içinde değiştiğinde varsayılanları daha sonra değiştirebilmenin bir yolu olarak bu yöntemleri uygulamanızda kullanın.

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

Oluşturucular

SslStream(Stream)

Belirtilen Streamöğesini kullanarak sınıfının yeni bir örneğini SslStream başlatır.

SslStream(Stream, Boolean)

Belirtilen Stream ve akış kapatma davranışını kullanarak sınıfının yeni bir örneğini SslStream başlatır.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback)

Belirtilen Stream, akış kapatma davranışı ve sertifika doğrulama temsilcisini kullanarak sınıfın yeni bir örneğini SslStream başlatır.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)

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

SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)

Belirtilen Streamkullanarak sınıfının yeni bir örneğini SslStream başlatır.

Özellikler

CanRead

Temel alınan akışın okunabilir olup olmadığını gösteren bir Boolean değer alır.

CanSeek

Temel alınan akışın aranabilir olup olmadığını gösteren bir Boolean değer alır.

CanTimeout

Temel alınan akışın zaman aşımlarını destekleyip desteklemediğini gösteren bir Boolean değer alır.

CanWrite

Temel alınan akışın yazılabilir olup olmadığını gösteren bir Boolean değer alır.

CheckCertRevocationStatus

Sertifika doğrulama işlemi sırasında sertifika iptal listesinin denetlenip denetlenmediğini belirten bir Boolean değer 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ı (CS) 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

Veri göndermek ve almak için bu AuthenticatedStream akış tarafından 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ğer alır.

IsEncrypted

Bunun veri şifreleme kullanıp kullanmadığını SslStream belirten bir Boolean değer alır.

IsMutuallyAuthenticated

Hem sunucunun hem de istemcinin kimliğinin doğrulanıp doğrulanmamış olduğunu gösteren bir Boolean değer alır.

IsServer

Bunun SslStream tarafından kullanılan bağlantının yerel tarafının sunucu olarak doğrulanıp doğrulanmamış olduğunu belirten bir Boolean değer alır.

IsSigned

Bu akış kullanılarak gönderilen verilerin imzalanıp imzalanmadığını gösteren bir Boolean değer 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 akış 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şmalı 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 blokları olan 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. Bu bir DNS adı veya IP adresi olabilir.

TransportContext

Genişletilmiş koruma kullanarak kimlik doğrulaması için kullanılan öğesini 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ında 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ında 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ında 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ında 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, özellik paketinde sslClientAuthenticationOptions 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 protokollerini 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)

Belirtilen sertifikayı 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)

Belirtilen sertifikayı 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, 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 tarafından optionsCallbackdö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, özellik paketinde sslClientAuthenticationOptions belirtilen bilgileri kullanır.

AuthenticateAsServerAsync(X509Certificate)

Sunucunun 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 kullanılır.

AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)

Belirtilen sertifikaları, gereksinimleri ve güvenlik protokollerini zaman uyumsuz bir işlem olarak 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(X509Certificate, Boolean, SslProtocols, Boolean)

Belirtilen sertifikaları, gereksinimleri ve güvenlik protokollerini zaman uyumsuz bir işlem olarak 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.

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, sunucunun ve isteğe bağlı olarak belirtilen sertifikaları ve sistem varsayılan güvenlik protokollerini kullanarak 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)

Sunucunun ve isteğe bağlı olarak belirtilen sertifikaları ve güvenlik protokollerini kullanarak istemcinin kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için istemciler 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 ve isteğe bağlı olarak belirtilen sertifika ve gereksinimleri ve sistem varsayılan 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.

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.

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Zaman uyumsuz bir okuma işlemi başlatır. (Bunun yerine kullanmayı ReadAsync(Byte[], Int32, Int32) göz önünde bulundurun.)

(Devralındığı yer: Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Belirtilen arabellekten akışa s yazan Bytezaman uyumsuz bir yazma işlemi başlatır.

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Zaman uyumsuz bir yazma işlemi başlatır. (Bunun yerine kullanmayı WriteAsync(Byte[], Int32, Int32) göz önünde bulundurun.)

(Devralındığı yer: Stream)
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 bir ş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 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 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 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()
Kullanımdan kalktı.
Kullanımdan kalktı.
Kullanımdan kalktı.

Bir WaitHandle nesnesi ayırır.

(Devralındığı yer: Stream)
Dispose()

Stream tarafı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 yönetilen kaynakları isteğe bağlı olarak serbest bırakır.

Dispose(Boolean)

AuthenticatedStream tarafından kullanılan yönetilmeyen kaynakları serbest bırakır ve yönetilen kaynakları isteğe bağlı olarak serbest bırakır.

(Devralındığı yer: AuthenticatedStream)
DisposeAsync()

tarafından SslStreamkullanılan yönetilmeyen ve yönetilen kaynakları zaman uyumsuz olarak serbest bırakır.

DisposeAsync()

tarafından AuthenticatedStreamkullanılan yönetilmeyen ve yönetilen kaynakları zaman uyumsuz olarak serbest bırakır.

(Devralındığı yer: AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)

Önceki bir çağrısıyla BeginAuthenticateAsClientbaşlatılan bekleyen zaman uyumsuz sunucu kimlik doğrulama işlemini sonlandırır.

EndAuthenticateAsServer(IAsyncResult)

Önceki bir çağrısıyla BeginAuthenticateAsClientbaşlatılan bekleyen zaman uyumsuz istemci kimlik doğrulama işlemini sonlandırır.

EndRead(IAsyncResult)

Önceki bir çağrısıyla BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)başlatılan zaman uyumsuz okuma işlemini sonlandırır.

EndRead(IAsyncResult)

Bekleyen zaman uyumsuz okumanın tamamlanmasını bekler. (Bunun yerine kullanmayı ReadAsync(Byte[], Int32, Int32) göz önünde bulundurun.)

(Devralındığı yer: Stream)
EndWrite(IAsyncResult)

Önceki bir çağrısıyla BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)başlatılan zaman uyumsuz yazma işlemini sonlandırır.

EndWrite(IAsyncResult)

Zaman uyumsuz yazma işlemini sonlandırır. (Bunun yerine kullanmayı WriteAsync(Byte[], Int32, Int32) düşünün.)

(Devralındığı yer: Stream)
Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.

(Devralındığı yer: Object)
Finalize()

SslStream tarafından kullanılan tüm kaynakları serbest bırakır.

Flush()

Arabelleğe alınan verilerin temel alınan cihaza yazılmasına 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.

FlushAsync(CancellationToken)

Bu akış için tüm arabellekleri zaman uyumsuz olarak temizler, arabelleğe alınan verilerin temel alınan cihaza yazılmasına neden olur ve iptal isteklerini izler.

(Devralındığı yer: Stream)
GetHashCode()

Varsayılan karma işlevi işlevi görür.

(Devralındığı yer: Object)
GetLifetimeService()
Kullanımdan kalktı.

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()

Type Geçerli örneğini alır.

(Devralındığı yer: Object)
InitializeLifetimeService()
Kullanımdan kalktı.

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 Objectöğesinin sığ bir kopyasını oluşturur.

(Devralındığı yer: Object)
MemberwiseClone(Boolean)

Geçerli MarshalByRefObject nesnenin sığ bir kopyasını oluşturur.

(Devralındığı yer: MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)

Kimliği doğrulanmış bağlantıda istemci sertifikası üzerinde anlaşma yapar.

ObjectInvariant()
Kullanımdan kalktı.

için Contractdestek 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ı kadar 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(Byte[], Int32, Int32, CancellationToken)

Geçerli akıştan zaman uyumsuz olarak bir bayt dizisi okur, okunan bayt sayısına göre akış içindeki konumu ilerletir ve iptal isteklerini izler.

(Devralındığı yer: Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Bu akıştaki verileri zaman uyumsuz olarak okur ve belirtilen bellek aralığında depolar.

ReadAsync(Memory<Byte>, CancellationToken)

Geçerli akıştan zaman uyumsuz olarak bir bayt dizisi okur, okunan bayt sayısına göre akış içindeki konumu ilerletir ve iptal isteklerini izler.

(Devralındığı yer: Stream)
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 zaman uyumsuz olarak en az sayıda bayt okur, okunan bayt sayısına göre akış içindeki konumu ilerletir ve iptal isteklerini izler.

(Devralındığı yer: Stream)
ReadByte()

konumundan SslStream bir bayt okur ve akış içindeki konumu bir bayt ilerletir veya akışın sonundaysa -1 döndürür.

ReadByte()

Akıştan bir bayt okur ve akışın içindeki konumu bir bayt ilerletir veya akışın sonundaysa -1 döndürür.

(Devralındığı yer: Stream)
ReadExactly(Byte[], Int32, Int32)

count Geçerli akıştan 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 doldurulana kadar buffer akış içindeki konumu ilerler.

(Devralındığı yer: Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)

Geçerli akıştaki bayt sayısını zaman uyumsuz olarak okur count , 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, doldurulana kadar buffer akış içindeki konumu ilerler ve iptal isteklerini izler.

(Devralındığı yer: Stream)
Seek(Int64, SeekOrigin)

Bir NotSupportedExceptionatar.

SetLength(Int64)

Temel alınan akışın uzunluğunu ayarlar.

ShutdownAsync()

Bu SslStream'i kapatır.

ToString()

Geçerli nesneyi temsil eden dizeyi 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 Bytes yazı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 bu akıştaki geçerli konumu yazılan bayt sayısı kadar 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(Byte[], Int32, Int32, CancellationToken)

Zaman uyumsuz olarak geçerli akışa bir bayt dizisi yazar, bu akıştaki geçerli konumu yazılan bayt sayısına göre ilerletir ve iptal isteklerini izler.

(Devralındığı yer: Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Verileri salt okunur bayt bellek aralığından temel alınan akışa zaman uyumsuz olarak yazar.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Zaman uyumsuz olarak geçerli akışa bir bayt dizisi yazar, bu akıştaki geçerli konumu yazılan bayt sayısına göre ilerletir ve iptal isteklerini izler.

(Devralındığı yer: Stream)
WriteByte(Byte)

Akıştaki geçerli konuma bir bayt yazar ve akış içindeki konumu bir bayt ilerletir.

(Devralındığı yer: Stream)

Uzantı Metotları

ConfigureAwait(IAsyncDisposable, Boolean)

Zaman uyumsuz bir atılabilir öğeden döndürülen görevlerde awaits işleminin nasıl gerçekleştirildiğini yapılandırıyor.

Şunlara uygulanır

Ayrıca bkz.