Partage via


SslStream Classe

Définition

Fournit un flux utilisé pour la communication client-serveur qui utilise le protocole de sécurité SSL (Secure Socket Layer) pour authentifier le serveur et éventuellement le client.

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
Héritage
Héritage

Exemples

L’exemple de code suivant illustre la création d’un TcpListener qui utilise la classe SslStream pour communiquer avec les clients.

#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

L’exemple de code suivant illustre la création d’un TcpClient qui utilise la classe SslStream pour communiquer avec un serveur.

#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

Remarques

Les protocoles SSL permettent de garantir la confidentialité et la vérification de l’intégrité des messages transmis à l’aide d’un SslStream. Une connexion SSL, telle que celle fournie par SslStream, doit être utilisée lors de la communication d’informations sensibles entre un client et un serveur. L’utilisation d’un SslStream permet d’empêcher toute personne de lire et de falsifier les informations pendant qu’elle est en transit sur le réseau.

Une instance SslStream transmet des données à l’aide d’un flux que vous fournissez lors de la création du SslStream. Lorsque vous fournissez ce flux sous-jacent, vous avez la possibilité de spécifier si la fermeture du SslStream ferme également le flux sous-jacent. En règle générale, la classe SslStream est utilisée avec les classes TcpClient et TcpListener. La méthode GetStream fournit une NetworkStream adaptée à une utilisation avec la classe SslStream.

Après avoir créé un SslStream, le serveur et éventuellement, le client doit être authentifié. Le serveur doit fournir un certificat X509 qui établit la preuve de son identité et peut demander que le client le fasse également. L’authentification doit être effectuée avant de transmettre des informations à l’aide d’un SslStream. Les clients lancent l’authentification à l’aide des méthodes de AuthenticateAsClient synchrones, qui bloquent jusqu’à la fin de l’authentification, ou les méthodes de BeginAuthenticateAsClient asynchrones, qui ne bloquent pas l’attente de l’authentification. Les serveurs lancent l’authentification à l’aide des méthodes de AuthenticateAsServer synchrones ou de BeginAuthenticateAsServer asynchrones. Le client et le serveur doivent lancer l’authentification.

L’authentification est gérée par le fournisseur de canal SSPI (Security Support Provider). Le client a la possibilité de contrôler la validation du certificat du serveur en spécifiant un délégué RemoteCertificateValidationCallback lors de la création d’un SslStream. Le serveur peut également contrôler la validation en fournissant un délégué RemoteCertificateValidationCallback. La méthode référencée par le délégué inclut le certificat du tiers distant et toutes les erreurs rencontrées par SSPI lors de la validation du certificat. Notez que si le serveur spécifie un délégué, la méthode du délégué est appelée, que le serveur ait demandé l’authentification du client. Si le serveur n’a pas demandé l’authentification du client, la méthode déléguée du serveur reçoit un certificat Null et un tableau vide d’erreurs de certificat.

Si le serveur requiert l’authentification du client, le client doit spécifier un ou plusieurs certificats pour l’authentification. Si le client a plusieurs certificats, le client peut fournir un délégué LocalCertificateSelectionCallback pour sélectionner le certificat approprié pour le serveur. Les certificats du client doivent se trouver dans le magasin de certificats « My » de l’utilisateur actuel. L’authentification du client via des certificats n’est pas prise en charge pour le protocole Ssl2 (SSL version 2).

Si l’authentification échoue, vous recevez un AuthenticationExceptionet le SslStream n’est plus utilisable. Vous devez fermer cet objet et supprimer toutes les références à cet objet afin qu’il puisse être collecté par le garbage collector.

Lorsque le processus d’authentification, également appelé négociation SSL, réussit, l’identité du serveur (et éventuellement, le client) est établie et la SslStream peut être utilisée par le client et le serveur pour échanger des messages. Avant d’envoyer ou de recevoir des informations, le client et le serveur doivent vérifier les services de sécurité et les niveaux fournis par l'SslStream pour déterminer si le protocole, les algorithmes et les forces sélectionnés répondent à leurs exigences en matière d’intégrité et de confidentialité. Si les paramètres actuels ne sont pas suffisants, le flux doit être fermé. Vous pouvez vérifier les services de sécurité fournis par le SslStream à l’aide des propriétés IsEncrypted et IsSigned. Le tableau suivant présente les éléments qui signalent les paramètres de chiffrement utilisés pour l’authentification, le chiffrement et la signature de données.

Élément Membres
Protocole de sécurité utilisé pour authentifier le serveur et, éventuellement, le client. Propriété SslProtocol et énumération SslProtocols associée.
Algorithme d’échange de clés. Propriété KeyExchangeAlgorithm et énumération ExchangeAlgorithmType associée.
Algorithme d’intégrité des messages. Propriété HashAlgorithm et énumération HashAlgorithmType associée.
Algorithme de confidentialité des messages. Propriété CipherAlgorithm et énumération CipherAlgorithmType associée.
Points forts des algorithmes sélectionnés. Propriétés KeyExchangeStrength, HashStrengthet CipherStrength.

Après une authentification réussie, vous pouvez envoyer des données à l’aide des méthodes de Write synchrones ou de BeginWrite asynchrones. Vous pouvez recevoir des données à l’aide des méthodes de Read synchrones ou de BeginRead asynchrones.

Si vous avez spécifié à l'SslStream que le flux sous-jacent doit être ouvert, vous êtes responsable de la fermeture de ce flux lorsque vous avez terminé de l’utiliser.

Note

Si l’application qui crée l’objet SslStream s’exécute avec les informations d’identification d’un utilisateur normal, l’application ne pourra pas accéder aux certificats installés dans le magasin d’ordinateurs local, sauf si l’autorisation a été explicitement accordée à l’utilisateur.

SslStream suppose qu’un délai d’expiration avec tout autre IOException lorsqu’un flux intérieur est traité comme fatal par son appelant. La réutilisation d’une instance de SslStream après un délai d’expiration retourne le garbage. Une application doit Close l'SslStream et lever une exception dans ces cas.

.NET Framework 4.6 inclut une nouvelle fonctionnalité de sécurité qui bloque les algorithmes de chiffrement et de hachage non sécurisés pour les connexions. Les applications utilisant TLS/SSL via des API telles que HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream, etc. et ciblant .NET Framework 4.6 obtiennent le comportement plus sécurisé par défaut.

Les développeurs peuvent refuser ce comportement afin de maintenir l’interopérabilité avec leurs services SSL3 existants OU TLS w/ RC4. Cet article explique comment modifier votre code afin que le nouveau comportement soit désactivé.

.NET Framework 4.7 ajoute de nouvelles surcharges pour les méthodes qui authentifient SslStreams qui ne spécifient pas de version TLS, mais utilisent plutôt la version TLS définie comme valeur par défaut du système dans SCHANNEL. Utilisez ces méthodes dans votre application pour pouvoir modifier ultérieurement les valeurs par défaut en tant que meilleures pratiques de version TLS au fil du temps, sans avoir à reconstruire et redéployer votre application.

Consultez également bonnes pratiques TLS (Transport Layer Security) avec le.NET Framework.

Constructeurs

SslStream(Stream)

Initialise une nouvelle instance de la classe SslStream à l’aide de la Streamspécifiée.

SslStream(Stream, Boolean)

Initialise une nouvelle instance de la classe SslStream à l’aide du comportement de fermeture de flux et de Stream spécifiés.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback)

Initialise une nouvelle instance de la classe SslStream à l’aide du Streamspécifié, du comportement de fermeture de flux et du délégué de validation de certificat.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)

Initialise une nouvelle instance de la classe SslStream à l’aide du Streamspécifié, du comportement de fermeture de flux, du délégué de validation de certificat et du délégué de sélection de certificat spécifiés.

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

Initialise une nouvelle instance de la classe SslStream à l’aide de la Streamspécifiée.

Propriétés

CanRead

Obtient une valeur Boolean qui indique si le flux sous-jacent est lisible.

CanSeek

Obtient une valeur Boolean qui indique si le flux sous-jacent peut être recherché.

CanTimeout

Obtient une valeur Boolean qui indique si le flux sous-jacent prend en charge les délais d’attente.

CanWrite

Obtient une valeur Boolean qui indique si le flux sous-jacent est accessible en écriture.

CheckCertRevocationStatus

Obtient une valeur Boolean qui indique si la liste de révocation de certificats est vérifiée pendant le processus de validation de certificat.

CipherAlgorithm

Obtient une valeur qui identifie l’algorithme de chiffrement en bloc utilisé par cette SslStream.

CipherStrength

Obtient une valeur qui identifie la force de l’algorithme de chiffrement utilisé par cette SslStream.

HashAlgorithm

Obtient l’algorithme utilisé pour générer des codes d’authentification de message (MAC).

HashStrength

Obtient une valeur qui identifie la force de l’algorithme de hachage utilisé par cette instance.

InnerStream

Obtient le flux utilisé par cette AuthenticatedStream pour l’envoi et la réception de données.

(Hérité de AuthenticatedStream)
IsAuthenticated

Obtient une valeur Boolean qui indique si l’authentification a réussi.

IsEncrypted

Obtient une valeur Boolean qui indique si cette SslStream utilise le chiffrement des données.

IsMutuallyAuthenticated

Obtient une valeur Boolean qui indique si le serveur et le client ont été authentifiés.

IsServer

Obtient une valeur Boolean qui indique si le côté local de la connexion utilisée par cette SslStream a été authentifié en tant que serveur.

IsSigned

Obtient une valeur Boolean qui indique si les données envoyées à l’aide de ce flux sont signées.

KeyExchangeAlgorithm

Obtient l’algorithme d’échange de clés utilisé par cette SslStream.

KeyExchangeStrength

Obtient une valeur qui identifie la force de l’algorithme d’échange de clés utilisé par cette instance.

LeaveInnerStreamOpen

Obtient si le flux utilisé par cette AuthenticatedStream pour l’envoi et la réception de données a été laissé ouvert.

(Hérité de AuthenticatedStream)
Length

Obtient la longueur du flux sous-jacent.

LocalCertificate

Obtient le certificat utilisé pour authentifier le point de terminaison local.

NegotiatedApplicationProtocol

Protocole d’application négocié dans la négociation TLS.

NegotiatedCipherSuite

Obtient la suite de chiffrement qui a été négociée pour cette connexion.

Position

Obtient ou définit la position actuelle dans le flux sous-jacent.

ReadTimeout

Obtient ou définit la durée, exprimée en millisecondes, un bloc d’opération de lecture en attente de données.

RemoteCertificate

Obtient le certificat utilisé pour authentifier le point de terminaison distant.

SslProtocol

Obtient une valeur qui indique le protocole de sécurité utilisé pour authentifier cette connexion.

TargetHostName

Obtient le nom du serveur auquel le client tente de se connecter. Ce nom est utilisé pour la validation du certificat de serveur. Il peut s’agir d’un nom DNS ou d’une adresse IP.

TransportContext

Obtient la TransportContext utilisée pour l’authentification à l’aide d’une protection étendue.

WriteTimeout

Obtient ou définit la durée pendant laquelle une opération d’écriture bloque l’attente des données.

Méthodes

AuthenticateAsClient(SslClientAuthenticationOptions)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur.

AuthenticateAsClient(String)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur.

AuthenticateAsClient(String, X509CertificateCollection, Boolean)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur. Le processus d’authentification utilise la collection de certificats spécifiée et le protocole SSL par défaut du système.

AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur. Le processus d’authentification utilise la collection de certificats et le protocole SSL spécifiés.

AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise des informations spécifiées dans le conteneur de propriétés sslClientAuthenticationOptions.

AuthenticateAsClientAsync(String)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur en tant qu’opération asynchrone.

AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise la collection de certificats spécifiée et le protocole SSL par défaut du système.

AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise la collection de certificats et le protocole SSL spécifiés.

AuthenticateAsServer(SslServerAuthenticationOptions)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide du certificat spécifié.

AuthenticateAsServer(X509Certificate)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide du certificat spécifié.

AuthenticateAsServer(X509Certificate, Boolean, Boolean)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide des certificats et exigences spécifiés, et à l’aide du protocole de sécurité par défaut du système.

AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide des certificats, exigences et protocole de sécurité spécifiés.

AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise les informations retournées par optionsCallback.

AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise des informations spécifiées dans le conteneur de propriétés sslClientAuthenticationOptions.

AuthenticateAsServerAsync(X509Certificate)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide du certificat spécifié en tant qu’opération asynchrone.

AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide des certificats, exigences et protocole de sécurité spécifiés en tant qu’opération asynchrone.

AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide des certificats, exigences et protocole de sécurité spécifiés en tant qu’opération asynchrone.

BeginAuthenticateAsClient(String, AsyncCallback, Object)

Appelé par les clients pour commencer une opération asynchrone pour authentifier le serveur et éventuellement le client.

BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)

Appelé par les clients pour commencer une opération asynchrone pour authentifier le serveur et éventuellement le client à l’aide des certificats spécifiés et du protocole de sécurité par défaut du système.

BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)

Appelé par les clients pour commencer une opération asynchrone pour authentifier le serveur et éventuellement le client à l’aide des certificats et du protocole de sécurité spécifiés.

BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)

Appelé par les serveurs pour commencer une opération asynchrone pour authentifier le client et éventuellement le serveur dans une connexion client-serveur.

BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)

Appelé par les serveurs pour commencer une opération asynchrone pour authentifier le serveur et éventuellement le client à l’aide des certificats et exigences spécifiés et du protocole de sécurité par défaut du système.

BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)

Appelé par les serveurs pour commencer une opération asynchrone pour authentifier le serveur et éventuellement le client à l’aide des certificats, exigences et protocole de sécurité spécifiés.

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

Commence une opération de lecture asynchrone qui lit les données du flux et les stocke dans le tableau spécifié.

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

Commence une opération de lecture asynchrone. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Commence une opération d’écriture asynchrone qui écrit Bytes à partir de la mémoire tampon spécifiée dans le flux.

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

Commence une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
Close()

Ferme le flux actuel et libère toutes les ressources (telles que les sockets et les handles de fichiers) associées au flux actuel. Au lieu d’appeler cette méthode, vérifiez que le flux est correctement supprimé.

(Hérité de Stream)
CopyTo(Stream)

Lit les octets du flux actuel et les écrit dans un autre flux. Les deux positions de flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyTo(Stream, Int32)

Lit les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée. Les deux positions de flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream)

Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux. Les deux positions de flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream, CancellationToken)

Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’un jeton d’annulation spécifié. Les deux positions de flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream, Int32)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée. Les deux positions de flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon et d’un jeton d’annulation spécifiés. Les deux positions de flux sont avancées par le nombre d’octets copiés.

(Hérité de Stream)
CreateObjRef(Type)

Crée un objet qui contient toutes les informations pertinentes requises pour générer un proxy utilisé pour communiquer avec un objet distant.

(Hérité de MarshalByRefObject)
CreateWaitHandle()
Obsolète.
Obsolète.
Obsolète.

Alloue un objet WaitHandle.

(Hérité de Stream)
Dispose()

Libère toutes les ressources utilisées par le Stream.

(Hérité de Stream)
Dispose(Boolean)

Libère les ressources non managées utilisées par le SslStream et libère éventuellement les ressources managées.

Dispose(Boolean)

Libère les ressources non managées utilisées par le AuthenticatedStream et libère éventuellement les ressources managées.

(Hérité de AuthenticatedStream)
DisposeAsync()

Libère de façon asynchrone les ressources non managées et gérées utilisées par le SslStream.

DisposeAsync()

Libère de façon asynchrone les ressources non managées et gérées utilisées par le AuthenticatedStream.

(Hérité de AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)

Termine une opération d’authentification de serveur asynchrone en attente démarrée avec un appel précédent à BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

Termine une opération d’authentification client asynchrone en attente démarrée avec un appel précédent à BeginAuthenticateAsClient.

EndRead(IAsyncResult)

Termine une opération de lecture asynchrone démarrée avec un appel précédent à BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).

EndRead(IAsyncResult)

Attend la fin de la lecture asynchrone en attente. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
EndWrite(IAsyncResult)

Termine une opération d’écriture asynchrone démarrée avec un appel précédent à BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).

EndWrite(IAsyncResult)

Termine une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
Equals(Object)

Détermine si l’objet spécifié est égal à l’objet actuel.

(Hérité de Object)
Finalize()

Libère toutes les ressources utilisées par le SslStream.

Flush()

Entraîne l’écriture de toutes les données mises en mémoire tampon sur l’appareil sous-jacent.

FlushAsync()

Efface de façon asynchrone toutes les mémoires tampons de ce flux et entraîne l’écriture de toutes les données mises en mémoire tampon sur l’appareil sous-jacent.

(Hérité de Stream)
FlushAsync(CancellationToken)

Écrit de manière asynchrone toutes les données mises en mémoire tampon sur l’appareil sous-jacent.

FlushAsync(CancellationToken)

Efface de façon asynchrone toutes les mémoires tampons de ce flux, entraîne l’écriture de toutes les données mises en mémoire tampon sur l’appareil sous-jacent et surveille les demandes d’annulation.

(Hérité de Stream)
GetHashCode()

Sert de fonction de hachage par défaut.

(Hérité de Object)
GetLifetimeService()
Obsolète.

Récupère l’objet de service de durée de vie actuel qui contrôle la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
GetType()

Obtient la Type de l’instance actuelle.

(Hérité de Object)
InitializeLifetimeService()
Obsolète.

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Objectactuel.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l’objet MarshalByRefObject actuel.

(Hérité de MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)

Négocie le certificat client sur la connexion authentifiée.

ObjectInvariant()
Obsolète.

Fournit la prise en charge d’un Contract.

(Hérité de Stream)
Read(Byte[], Int32, Int32)

Lit les données de ce flux et les stocke dans le tableau spécifié.

Read(Span<Byte>)

En cas de substitution dans une classe dérivée, lit une séquence d’octets à partir du flux actuel et avance la position dans le flux par le nombre d’octets lus.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32)

Lit de façon asynchrone une séquence d’octets à partir du flux actuel et avance la position dans le flux en fonction du nombre d’octets lus.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit de façon asynchrone les données de ce flux et les stocke dans la plage spécifiée d’un tableau d’octets.

ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit de façon asynchrone une séquence d’octets à partir du flux actuel, avance la position dans le flux en fonction du nombre d’octets lus et surveille les demandes d’annulation.

(Hérité de Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Lit de façon asynchrone les données de ce flux et les stocke dans la plage de mémoire spécifiée.

ReadAsync(Memory<Byte>, CancellationToken)

Lit de façon asynchrone une séquence d’octets à partir du flux actuel, avance la position dans le flux en fonction du nombre d’octets lus et surveille les demandes d’annulation.

(Hérité de Stream)
ReadAtLeast(Span<Byte>, Int32, Boolean)

Lit au moins un nombre minimal d’octets du flux actuel et avance la position dans le flux par le nombre d’octets lus.

(Hérité de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)

Lit de façon asynchrone au moins un nombre minimal d’octets à partir du flux actuel, avance la position dans le flux par le nombre d’octets lus et surveille les demandes d’annulation.

(Hérité de Stream)
ReadByte()

Lit un octet à partir de la SslStream et avance la position dans le flux d’un octet, ou retourne -1 si à la fin du flux.

ReadByte()

Lit un octet à partir du flux et avance la position dans le flux d’un octet, ou retourne -1 si à la fin du flux.

(Hérité de Stream)
ReadExactly(Byte[], Int32, Int32)

Lit count nombre d’octets du flux actuel et avance la position dans le flux.

(Hérité de Stream)
ReadExactly(Span<Byte>)

Lit les octets du flux actuel et avance la position dans le flux jusqu’à ce que le buffer soit rempli.

(Hérité de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)

Lit de façon asynchrone count nombre d’octets du flux actuel, avance la position dans le flux et surveille les demandes d’annulation.

(Hérité de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)

Lit de manière asynchrone les octets du flux actuel, avance la position dans le flux jusqu’à ce que le buffer soit rempli et surveille les demandes d’annulation.

(Hérité de Stream)
Seek(Int64, SeekOrigin)

Lève une NotSupportedException.

SetLength(Int64)

Définit la longueur du flux sous-jacent.

ShutdownAsync()

Arrête ce SslStream.

ToString()

Retourne une chaîne qui représente l’objet actuel.

(Hérité de Object)
Write(Byte[])

Écrit les données spécifiées dans ce flux.

Write(Byte[], Int32, Int32)

Écrivez le nombre spécifié de Bytes dans le flux sous-jacent à l’aide de la mémoire tampon et du décalage spécifiés.

Write(ReadOnlySpan<Byte>)

En cas de substitution dans une classe dérivée, écrit une séquence d’octets dans le flux actuel et avance la position actuelle dans ce flux par le nombre d’octets écrits.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32)

Écrit de façon asynchrone une séquence d’octets dans le flux actuel et avance la position actuelle dans ce flux par le nombre d’octets écrits.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Écrit de façon asynchrone des données dans le flux sous-jacent à partir de la plage spécifiée d’un tableau d’octets.

WriteAsync(Byte[], Int32, Int32, CancellationToken)

Écrit de façon asynchrone une séquence d’octets dans le flux actuel, avance la position actuelle dans ce flux par le nombre d’octets écrits et surveille les demandes d’annulation.

(Hérité de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Écrit de façon asynchrone des données dans le flux sous-jacent à partir d’une plage de mémoire d’octets en lecture seule.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Écrit de façon asynchrone une séquence d’octets dans le flux actuel, avance la position actuelle dans ce flux par le nombre d’octets écrits et surveille les demandes d’annulation.

(Hérité de Stream)
WriteByte(Byte)

Écrit un octet à la position actuelle dans le flux et avance la position dans le flux d’un octet.

(Hérité de Stream)

Méthodes d’extension

CopyToAsync(Stream, PipeWriter, CancellationToken)

Lit de manière asynchrone les octets de l'Stream et les écrit dans le PipeWriterspécifié, à l’aide d’un jeton d’annulation.

ConfigureAwait(IAsyncDisposable, Boolean)

Configure la façon dont les attentes sur les tâches retournées à partir d’un jetable asynchrone sont effectuées.

S’applique à

Voir aussi