NegotiateStream Classe

Définition

Espace de noms:

System.Net.Security

Assembly:

System.Net.Security.dll

Source:

NegotiateStream.cs

Fournit un flux qui utilise le protocole de sécurité Negotiate pour authentifier le client, et éventuellement le serveur, dans la communication client-serveur.

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

public class NegotiateStream : System.Net.Security.AuthenticatedStream

type NegotiateStream = class
    inherit AuthenticatedStream

Public Class NegotiateStream
Inherits AuthenticatedStream

Héritage

Object

MarshalByRefObject

Stream

AuthenticatedStream

NegotiateStream

Exemples

L’exemple suivant illustre le côté client d’une connexion client-serveur qui utilise le NegotiateStream. Le client s’authentifie et envoie un message au serveur de façon asynchrone.

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Text;

// The following class displays the properties of an authenticatedStream.
public ref class AuthenticatedStreamReporter
{
public:
   static void DisplayProperties( AuthenticatedStream^ stream )
   {
      Console::WriteLine( L"IsAuthenticated: {0}", stream->IsAuthenticated );
      Console::WriteLine( L"IsMutuallyAuthenticated: {0}", stream->IsMutuallyAuthenticated );
      Console::WriteLine( L"IsEncrypted: {0}", stream->IsEncrypted );
      Console::WriteLine( L"IsSigned: {0}", stream->IsSigned );
      Console::WriteLine( L"IsServer: {0}", stream->IsServer );
   }

};


public ref class ASynchronousAuthenticatingTcpClient
{
private:
   static TcpClient^ client = nullptr;

public:
   void Main()
   {
      
      // Establish the remote endpoint for the socket.
      // For this example, use the local machine.
      IPHostEntry^ ipHostInfo = Dns::GetHostEntry( Dns::GetHostName() );
      IPAddress^ ipAddress = ipHostInfo->AddressList[ 0 ];
      
      // Client and server use port 11000. 
      IPEndPoint^ remoteEP = gcnew IPEndPoint( ipAddress,11000 );
      
      // Create a TCP/IP socket.
      client = gcnew TcpClient;
      
      // Connect the socket to the remote endpoint.
      client->Connect( remoteEP );
      Console::WriteLine( L"Client connected to {0}.", remoteEP );
      
      // Ensure the client does not close when there is 
      // still data to be sent to the server.
      client->LingerState = (gcnew LingerOption( true,0 ));
      
      // Request authentication.
      NetworkStream^ clientStream = client->GetStream();
      NegotiateStream^ authStream = gcnew NegotiateStream( clientStream,false );
      
      // Pass the NegotiateStream as the AsyncState object 
      // so that it is available to the callback delegate.
      IAsyncResult^ ar = authStream->BeginAuthenticateAsClient( gcnew AsyncCallback( EndAuthenticateCallback ), authStream );
      
      Console::WriteLine( L"Client waiting for authentication..." );
      
      // Wait until the result is available.
      ar->AsyncWaitHandle->WaitOne();
      
      // Display the properties of the authenticated stream.
      AuthenticatedStreamReporter::DisplayProperties( authStream );
      
      // Send a message to the server.
      // Encode the test data into a byte array.
      array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the client." );
      ar = authStream->BeginWrite( message, 0, message->Length, gcnew AsyncCallback( EndWriteCallback ), authStream );
      
      ar->AsyncWaitHandle->WaitOne();
      Console::WriteLine( L"Sent {0} bytes.", message->Length );
      
      // Close the client connection.
      authStream->Close();
      Console::WriteLine( L"Client closed." );
   }


   // The following method is called when the authentication completes.
   static void EndAuthenticateCallback( IAsyncResult^ ar )
   {
      Console::WriteLine( L"Client ending authentication..." );
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(ar->AsyncState);
      
      // End the asynchronous operation.
      authStream->EndAuthenticateAsClient( ar );
      
      //         Console.WriteLine("AllowedImpersonation: {0}", authStream.AllowedImpersonation);
   }


   // The following method is called when the write operation completes.
   static void EndWriteCallback( IAsyncResult^ ar )
   {
      Console::WriteLine( L"Client ending write operation..." );
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(ar->AsyncState);
      
      // End the asynchronous operation.
      authStream->EndWrite( ar );
   }

};

void main()
{
   ASynchronousAuthenticatingTcpClient^ aatc = gcnew ASynchronousAuthenticatingTcpClient;
   aatc->Main();
}

using System;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Text;

namespace Examples.NegotiateStreamExample
{
    public class ASynchronousAuthenticatingTcpClient
    {
        static TcpClient client = null;

        public static void Main(String[] args)
        {
            // Establish the remote endpoint for the socket.
            // For this example, use the local machine.
            IPHostEntry ipHostInfo = Dns.GetHostEntry("localhost");
            IPAddress ipAddress = ipHostInfo.AddressList[0];
            // Client and server use port 11000.
            IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000);
            // Create a TCP/IP socket.
            client = new TcpClient();
            // Connect the socket to the remote endpoint.
            client.Connect(remoteEP);
            Console.WriteLine("Client connected to {0}.", remoteEP.ToString());
            // Ensure the client does not close when there is
            // still data to be sent to the server.
            client.LingerState = new LingerOption(true, 0);
            // Request authentication.
            NetworkStream clientStream = client.GetStream();
            NegotiateStream authStream = new NegotiateStream(clientStream, false);
            // Pass the NegotiateStream as the AsyncState object
            // so that it is available to the callback delegate.
            Task authenticateTask = authStream
                .AuthenticateAsClientAsync()
                .ContinueWith(task =>
                {
                    Console.WriteLine("Client ending authentication...");
                    Console.WriteLine("ImpersonationLevel: {0}", authStream.ImpersonationLevel);
                });

            Console.WriteLine("Client waiting for authentication...");
            // Wait until the result is available.
            authenticateTask.Wait();
            // Display the properties of the authenticated stream.
            AuthenticatedStreamReporter.DisplayProperties(authStream);
            // Send a message to the server.
            // Encode the test data into a byte array.
            byte[] message = Encoding.UTF8.GetBytes("Hello from the client.");
            Task writeTask = authStream
                .WriteAsync(message, 0, message.Length)
                .ContinueWith(task =>
                {
                    Console.WriteLine("Client ending write operation...");
                });

            writeTask.Wait();
            Console.WriteLine("Sent {0} bytes.", message.Length);
            // Close the client connection.
            authStream.Close();
            Console.WriteLine("Client closed.");
        }
    }

    // The following class displays the properties of an authenticatedStream.
    public class AuthenticatedStreamReporter
    {
        public static void DisplayProperties(AuthenticatedStream stream)
        {
            Console.WriteLine("IsAuthenticated: {0}", stream.IsAuthenticated);
            Console.WriteLine("IsMutuallyAuthenticated: {0}", stream.IsMutuallyAuthenticated);
            Console.WriteLine("IsEncrypted: {0}", stream.IsEncrypted);
            Console.WriteLine("IsSigned: {0}", stream.IsSigned);
            Console.WriteLine("IsServer: {0}", stream.IsServer);
        }
    }
}

Imports System.Text
Imports System.Net.Sockets
Imports System.Net.Security
Imports System.Net

Namespace Examples.NegotiateStreamExample

    Public Class ASynchronousAuthenticatingTcpClient

        Shared client As TcpClient = Nothing

        Public Shared Sub Main(args As String())
            ' Establish the remote endpoint for the socket.
            ' For this example, use the local machine.
            Dim ipHostInfo = Dns.GetHostEntry("localhost")
            Dim ipAddress = ipHostInfo.AddressList(0)

            ' Client and server use port 11000. 
            Dim remoteEP As New IPEndPoint(ipAddress, 11000)

            ' Create a TCP/IP socket.
            client = New TcpClient()

            ' Connect the socket to the remote endpoint.
            client.Connect(remoteEP)
            Console.WriteLine("Client connected to {0}.", remoteEP.ToString())

            ' Ensure the client does not close when there is 
            ' still data to be sent to the server.
            client.LingerState = (New LingerOption(True, 0))

            ' Request authentication.
            Dim clientStream = client.GetStream()
            Dim authStream As New NegotiateStream(clientStream, False)

            ' Pass the NegotiateStream as the AsyncState object 
            ' so that it is available to the callback delegate.
            Dim ar = authStream.BeginAuthenticateAsClient(
                New AsyncCallback(AddressOf EndAuthenticateCallback), authStream)

            Console.WriteLine("Client waiting for authentication...")

            ' Wait until the result is available.
            ar.AsyncWaitHandle.WaitOne()

            ' Display the properties of the authenticated stream.
            AuthenticatedStreamReporter.DisplayProperties(authStream)

            ' Send a message to the server.
            ' Encode the test data into a byte array.
            Dim message = Encoding.UTF8.GetBytes("Hello from the client.")
            ar = authStream.BeginWrite(message, 0, message.Length, 
                New AsyncCallback(AddressOf EndWriteCallback), authStream)
            ar.AsyncWaitHandle.WaitOne()
            Console.WriteLine("Sent {0} bytes.", message.Length)

            ' Close the client connection.
            authStream.Close()
            Console.WriteLine("Client closed.")

        End Sub

        ' The following method is called when the authentication completes.
        Public Shared Sub EndAuthenticateCallback(ar As IAsyncResult)

            Console.WriteLine("Client ending authentication...")
            Dim authStream = CType(ar.AsyncState, NegotiateStream)
            Console.WriteLine("ImpersonationLevel: {0}", authStream.ImpersonationLevel)

            ' End the asynchronous operation.
            authStream.EndAuthenticateAsClient(ar)

        End Sub

        ' The following method is called when the write operation completes.
        Public Shared Sub EndWriteCallback(ar As IAsyncResult)

            Console.WriteLine("Client ending write operation...")
            Dim authStream = CType(ar.AsyncState, NegotiateStream)

            ' End the asynchronous operation.
            authStream.EndWrite(ar)

        End Sub
    End Class

    ' The following class displays the properties of an AuthenticatedStream.
    Public Class AuthenticatedStreamReporter
        Public Shared Sub DisplayProperties(stream As AuthenticatedStream)
            Console.WriteLine("IsAuthenticated: {0}", stream.IsAuthenticated)
            Console.WriteLine("IsMutuallyAuthenticated: {0}", stream.IsMutuallyAuthenticated)
            Console.WriteLine("IsEncrypted: {0}", stream.IsEncrypted)
            Console.WriteLine("IsSigned: {0}", stream.IsSigned)
            Console.WriteLine("IsServer: {0}", stream.IsServer)
        End Sub
    End Class
End Namespace

L’exemple de code suivant illustre le côté serveur d’une connexion client-serveur qui utilise le NegotiateStream pour authentifier le client et lire un message envoyé par le client.

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Security::Authentication;
using namespace System::Security::Principal;
using namespace System::Text;
using namespace System::IO;
using namespace System::Threading;

// ClientState is the AsyncState object.
private ref class ClientState
{
private:
   AuthenticatedStream^ authStream;
   TcpClient^ client;
   array<Byte>^buffer;
   StringBuilder^ message;
   ManualResetEvent^ waiter;

internal:
   ClientState( AuthenticatedStream^ a, TcpClient^ theClient )
   {
      authStream = a;
      client = theClient;
      message = nullptr;
      buffer = gcnew array<Byte>(2048);
      waiter = gcnew ManualResetEvent( false );
   }

internal:
   property TcpClient^ Client 
   {
      TcpClient^ get()
      {
         return client;
      }
   }

   property AuthenticatedStream^ AuthStream 
   {
      AuthenticatedStream^ get()
      {
         return authStream;
      }
  }

   property array<Byte>^ Buffer 
   {
      array<Byte>^ get()
      {
         return buffer;
      }

   }

   property StringBuilder^ Message 
   {
      StringBuilder^ get()
      {
         if ( message == nullptr )
                  message = gcnew StringBuilder;

         return message;
      }

   }

   property ManualResetEvent^ Waiter 
   {
      ManualResetEvent^ get()
      {
         return waiter;
      }

   }

};

public ref class AsynchronousAuthenticatingTcpListener
{
public:
   int Main()
   {
      
      // Create an IPv4 TCP/IP socket. 
      TcpListener^ listener = gcnew TcpListener( IPAddress::Any,11000 );
      
      // Listen for incoming connections.
      listener->Start();
      while ( true )
      {
         TcpClient^ clientRequest = nullptr;
         
         // Application blocks while waiting for an incoming connection.
         // Type CNTL-C to terminate the server.
         clientRequest = listener->AcceptTcpClient();
         Console::WriteLine( L"Client connected." );
         
         // A client has connected. 
         try
         {
            AuthenticateClient( clientRequest );
         }
         catch ( Exception^ e ) 
         {
            Console::WriteLine( e );
            continue;
         }

      }
   }


   static void AuthenticateClient( TcpClient^ clientRequest )
   {
      NetworkStream^ stream = clientRequest->GetStream();
      
      // Create the NegotiateStream.
      NegotiateStream^ authStream = gcnew NegotiateStream( stream,false );
      
      // Save the current client and NegotiateStream instance 
      // in a ClientState object.
      ClientState^ cState = gcnew ClientState( authStream,clientRequest );
      
      // Listen for the client authentication request.
      authStream->BeginAuthenticateAsServer( gcnew AsyncCallback( EndAuthenticateCallback ), cState );
      
      // Wait until the authentication completes.
      cState->Waiter->WaitOne();
      cState->Waiter->Reset();
      authStream->BeginRead( cState->Buffer, 0, cState->Buffer->Length, gcnew AsyncCallback( EndReadCallback ), cState );
      cState->Waiter->WaitOne();
      
      // Finished with the current client.
      authStream->Close();
      clientRequest->Close();
   }


   // The following method is invoked by the
   // BeginServerAuthenticate callback delegate.
   static void EndAuthenticateCallback( IAsyncResult^ ar )
   {
      
      // Get the saved data.
      ClientState^ cState = dynamic_cast<ClientState^>(ar->AsyncState);
      TcpClient^ clientRequest = cState->Client;
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(cState->AuthStream);
      Console::WriteLine( L"Ending authentication." );
      
      // Any exceptions that occurred during authentication are
      // thrown by the EndServerAuthenticate method.
      try
      {
         
         // This call blocks until the authentication is complete.
         authStream->EndAuthenticateAsServer( ar );
      }
      catch ( AuthenticationException^ e ) 
      {
         Console::WriteLine( e );
         Console::WriteLine( L"Authentication failed - closing connection." );
         cState->Waiter->Set();
         return;
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e );
         Console::WriteLine( L"Closing connection." );
         cState->Waiter->Set();
         return;
      }

      
      // Display properties of the authenticated client.
      IIdentity^ id = authStream->RemoteIdentity;
      Console::WriteLine( L"{0} was authenticated using {1}.", id->Name, id->AuthenticationType );
      cState->Waiter->Set();
   }


   static void EndReadCallback( IAsyncResult^ ar )
   {
      
      // Get the saved data.
      ClientState^ cState = dynamic_cast<ClientState^>(ar->AsyncState);
      TcpClient^ clientRequest = cState->Client;
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(cState->AuthStream);
      
      // Get the buffer that stores the message sent by the client.
      int bytes = -1;
      
      // Read the client message.
      try
      {
         bytes = authStream->EndRead( ar );
         cState->Message->Append( Encoding::UTF8->GetChars( cState->Buffer, 0, bytes ) );
         if ( bytes != 0 )
         {
            authStream->BeginRead( cState->Buffer, 0, cState->Buffer->Length, gcnew AsyncCallback( EndReadCallback ), cState );
            return;
         }
      }
      catch ( Exception^ e ) 
      {
         
         // A real application should do something
         // useful here, such as logging the failure.
         Console::WriteLine( L"Client message exception:" );
         Console::WriteLine( e );
         cState->Waiter->Set();
         return;
      }

      IIdentity^ id = authStream->RemoteIdentity;
      Console::WriteLine( L"{0} says {1}", id->Name, cState->Message );
      cState->Waiter->Set();
   }

};

void main()
{
   AsynchronousAuthenticatingTcpListener^ aatl = gcnew AsynchronousAuthenticatingTcpListener;
   aatl->Main();
}

using System;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Security.Principal;
using System.Text;
using System.IO;
using System.Threading;

namespace Examples.NegotiateStreamExample
{
    public class AsynchronousAuthenticatingTcpListener
    {
        public static void Main()
        {
            // Create an IPv4 TCP/IP socket.
            TcpListener listener = new TcpListener(IPAddress.Any, 11000);
            // Listen for incoming connections.
            listener.Start();
            while (true)
            {
                TcpClient clientRequest;
                // Application blocks while waiting for an incoming connection.
                // Type CNTL-C to terminate the server.
                clientRequest = listener.AcceptTcpClient();
                Console.WriteLine("Client connected.");
                // A client has connected.
                try
                {
                    AuthenticateClient(clientRequest);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            }
        }

        public static void AuthenticateClient(TcpClient clientRequest)
        {
            NetworkStream stream = clientRequest.GetStream();
            // Create the NegotiateStream.
            NegotiateStream authStream = new NegotiateStream(stream, false);
            // Save the current client and NegotiateStream instance
            // in a ClientState object.
            ClientState cState = new ClientState(authStream, clientRequest);
            // Listen for the client authentication request.
            Task authTask = authStream
                .AuthenticateAsServerAsync()
                .ContinueWith(task => { EndAuthenticateCallback(cState); });

            // Any exceptions that occurred during authentication are
            // thrown by the EndAuthenticateAsServer method.
            try
            {
                // This call blocks until the authentication is complete.
                authTask.Wait();
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Authentication failed - closing connection.");
                return;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Closing connection.");
                return;
            }

            Task<int> readTask = authStream
                .ReadAsync(cState.Buffer, 0, cState.Buffer.Length);

            readTask
                .ContinueWith((task) => { EndReadCallback(cState, task.Result); })
                .Wait();
            // Finished with the current client.
            authStream.Close();
            clientRequest.Close();
        }

        private static void EndAuthenticateCallback(ClientState cState)
        {
            // Get the saved data.
            NegotiateStream authStream = (NegotiateStream)cState.AuthenticatedStream;
            Console.WriteLine("Ending authentication.");

            // Display properties of the authenticated client.
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} was authenticated using {1}.",
                id.Name,
                id.AuthenticationType
            );
        }

        private static void EndReadCallback(ClientState cState, int bytes)
        {
            NegotiateStream authStream = (NegotiateStream)cState.AuthenticatedStream;
            // Read the client message.
            try
            {
                cState.Message.Append(Encoding.UTF8.GetChars(cState.Buffer, 0, bytes));
                if (bytes != 0)
                {
                    Task<int> readTask = authStream.ReadAsync(cState.Buffer, 0, cState.Buffer.Length);
                    readTask
                        .ContinueWith(task => { EndReadCallback(cState, task.Result); })
                        .Wait();

                    return;
                }
            }
            catch (Exception e)
            {
                // A real application should do something
                // useful here, such as logging the failure.
                Console.WriteLine("Client message exception:");
                Console.WriteLine(e);
                return;
            }
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} says {1}", id.Name, cState.Message.ToString());
        }
    }
    // ClientState is the AsyncState object.
    internal class ClientState
    {
        private StringBuilder _message = null;

        internal ClientState(AuthenticatedStream a, TcpClient theClient)
        {
            AuthenticatedStream = a;
            Client = theClient;
        }
        internal TcpClient Client { get; }

        internal AuthenticatedStream AuthenticatedStream { get; }

        internal byte[] Buffer { get; } = new byte[2048];

        internal StringBuilder Message
        {
            get { return _message ??= new StringBuilder(); }
        }
    }
}

Remarques

Utilisez la classe NegotiateStream pour l’authentification et pour sécuriser les informations transmises entre un client et un serveur. À l’aide de NegotiateStream, vous pouvez effectuer les opérations suivantes.

• Envoyez les informations d’identification du client au serveur pour l’emprunt d’identité ou la délégation.

• Demandez l’authentification du serveur.

• Chiffrez et/ou signez les données avant de les transmettre.

L’authentification doit être effectuée avant de transmettre des informations. Les clients demandent 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 en attendant la fin de l’authentification. Les serveurs demandent l’authentification à l’aide des méthodes de AuthenticateAsServer synchrones ou de BeginAuthenticateAsServer asynchrones. Le client, et éventuellement le serveur, est authentifié à l’aide du protocole de sécurité Negotiate. Le protocole Kerberos est utilisé pour l’authentification si le client et le serveur le prennent en charge ; sinon, NTLM est utilisé. La classe NegotiateStream effectue l’authentification à l’aide de l’interface du fournisseur de support de sécurité (SSPI).

Une fois l’authentification réussie, vous devez vérifier les propriétés IsEncrypted et IsSigned pour déterminer quels services de sécurité seront utilisés par le NegotiateStream pour sécuriser vos données pendant la transmission. Vérifiez la propriété IsMutuallyAuthenticated pour déterminer si l’authentification mutuelle s’est produite. Vous pouvez obtenir des informations sur le client ou le serveur distant à l’aide de la propriété RemoteIdentity.

Si l’authentification échoue, vous recevrez un AuthenticationException ou un InvalidCredentialException. Dans ce cas, vous pouvez réessayer l’authentification avec des informations d’identification différentes.

Vous envoyez des données à l’aide des méthodes Write synchrones ou asynchrones BeginWrite ou WriteAsync. Vous recevez des données à l’aide des méthodes Read synchrones ou asynchrones ReadAsync ou BeginRead. Si des services de sécurité tels que le chiffrement ou la signature sont activés, ceux-ci sont automatiquement appliqués à vos données par le NegotiateStream.

Le NegotiateStream transmet des données à l’aide d’un flux que vous fournissez lors de la création du NegotiateStream. Lorsque vous fournissez ce flux sous-jacent, vous avez la possibilité de spécifier si la fermeture du NegotiateStream ferme également le flux sous-jacent.

Constructeurs

NegotiateStream(Stream)	Initialise une nouvelle instance de la classe NegotiateStream à l’aide de la Streamspécifiée.
NegotiateStream(Stream, Boolean)	Initialise une nouvelle instance de la classe NegotiateStream à l’aide du comportement de fermeture de flux et de Stream spécifiés.

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.
ImpersonationLevel	Obtient une valeur qui indique comment le serveur peut utiliser les informations d’identification du client.
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 NegotiateStream 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 NegotiateStream 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.
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.
Position	Obtient ou définit la position actuelle dans le flux sous-jacent.
ReadTimeout	Obtient ou définit la durée pendant laquelle une opération de lecture bloque l’attente des données.
RemoteIdentity	Obtient des informations sur l’identité du tiers distant partageant ce flux authentifié.
WriteTimeout	Obtient ou définit la durée pendant laquelle une opération d’écriture bloque l’attente des données.

Méthodes

AuthenticateAsClient()	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise les informations d’identification du client et la liaison de canal spécifiées.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise les informations d’identification, les options d’authentification et la liaison de canal spécifiées.
AuthenticateAsClient(NetworkCredential, String)	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise les informations d’identification du client spécifiées.
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise les informations d’identification et les options d’authentification spécifiées.
AuthenticateAsClientAsync()	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur en tant qu’opération asynchrone.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise les informations d’identification du client et la liaison de canal spécifiées.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise les informations d’identification, les options d’authentification et la liaison de canal spécifiées.
AuthenticateAsClientAsync(NetworkCredential, String)	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise les informations d’identification du client spécifiées.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise les informations d’identification et les options d’authentification spécifiées.
AuthenticateAsServer()	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.
AuthenticateAsServer(ExtendedProtectionPolicy)	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise la stratégie de protection étendue spécifiée.
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise les informations d’identification du serveur, les options d’authentification et la stratégie de protection étendue spécifiée.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise les informations d’identification et les options d’authentification du serveur spécifiés.
AuthenticateAsServerAsync()	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur en tant qu’opération asynchrone.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise la stratégie de protection étendue spécifiée.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise les informations d’identification du serveur, les options d’authentification et la stratégie de protection étendue spécifiée.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur en tant qu’opération asynchrone. Le processus d’authentification utilise les informations d’identification et les options d’authentification du serveur spécifiés.
BeginAuthenticateAsClient(AsyncCallback, Object)	Appelé par les clients pour commencer une opération asynchrone pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Cette méthode ne bloque pas.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Appelé par les clients pour commencer une opération asynchrone pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise les informations d’identification et la liaison de canal spécifiées. Cette méthode ne bloque pas.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Appelé par les clients pour commencer une opération asynchrone pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise les informations d’identification, les options d’authentification et la liaison de canal spécifiées. Cette méthode ne bloque pas.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Appelé par les clients pour commencer une opération asynchrone pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise les informations d’identification spécifiées. Cette méthode ne bloque pas.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Appelé par les clients pour commencer une opération asynchrone pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur. Le processus d’authentification utilise les informations d’identification et les options d’authentification spécifiées. Cette méthode ne bloque pas.
BeginAuthenticateAsServer(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. Cette méthode ne bloque pas.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, 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. Le processus d’authentification utilise la stratégie de protection étendue spécifiée. Cette méthode ne bloque pas.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, 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. Le processus d’authentification utilise les informations d’identification du serveur, les options d’authentification et la stratégie de protection étendue spécifiée. Cette méthode ne bloque pas.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, 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. Le processus d’authentification utilise les informations d’identification et les options d’authentification du serveur spécifiés. Cette méthode ne bloque pas.
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é.
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.
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. 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 NegotiateStream et libère éventuellement les ressources managées.
DisposeAsync()	Libère de façon asynchrone les ressources non managées et gérées utilisées par le NegotiateStream.
EndAuthenticateAsClient(IAsyncResult)	Termine une opération d’authentification client asynchrone en attente qui a été démarrée avec un appel à BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Termine une opération d’authentification client asynchrone en attente qui a été démarrée avec un appel à BeginAuthenticateAsServer.
EndRead(IAsyncResult)	Termine une opération de lecture asynchrone qui a été démarrée avec un appel à BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Termine une opération d’écriture asynchrone qui a été démarrée avec un appel à BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
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.
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)
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 les données de façon asynchrone à partir de ce flux et les stocke dans le tableau spécifié.
ReadAsync(Memory<Byte>, CancellationToken)	Lit les données de manière asynchrone à partir de l'NegotiateStream et les stocke dans une plage de mémoire d’octets en tant qu’opération asynchrone.
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 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 NotSupportedException.
SetLength(Int64)	Définit la longueur du flux sous-jacent.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
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)	Écrivez de manière asynchrone le nombre spécifié de Bytes dans le flux sous-jacent.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Écrivez de manière asynchrone le nombre spécifié de Bytes dans le flux sous-jacent.
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.

Voir aussi

• modifications apportées à l’authentification NTLM pour HTTPWebRequest dans la version 3.5 SP1