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 les communications 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 manière 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 pour NegotiateStream 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 pour l’authentification NegotiateStream 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.

• Chiffrer et/ou signer des données avant de les transmettre.

L’authentification doit être effectuée avant de transmettre les informations. Les clients demandent l’authentification à l’aide des méthodes synchrones AuthenticateAsClient , qui bloquent jusqu’à la fin de l’authentification, ou des méthodes asynchrones BeginAuthenticateAsClient , qui ne bloquent pas en attendant la fin de l’authentification. Les serveurs demandent l’authentification à l’aide des méthodes synchrones AuthenticateAsServer ou asynchrones BeginAuthenticateAsServer . Le client, et éventuellement le serveur, sont authentifiés à 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 NegotiateStream classe effectue l’authentification à l’aide de l’interface SSPI (Security Support Provider Interface).

Lorsque l’authentification réussit, vous devez vérifier les IsEncrypted propriétés et IsSigned pour déterminer quels services de sécurité seront utilisés par le pour sécuriser vos données pendant la NegotiateStream transmission. Vérifiez la IsMutuallyAuthenticated propriété 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 RemoteIdentity propriété .

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 ou synchrones Write ou WriteAsync asynchronesBeginWrite. Vous recevez des données à l’aide des méthodes ou synchrones Read ou BeginRead asynchronesReadAsync. Si des services de sécurité tels que le chiffrement ou la signature sont activés, ils sont automatiquement appliqués à vos données par le NegotiateStream.

transmet NegotiateStream des données à l’aide d’un flux que vous fournissez lors de la création de .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 du Stream spécifié.
NegotiateStream(Stream, Boolean)	Initialise une nouvelle instance de la classe NegotiateStream en utilisant le Stream et le comportement de clôture de flux spécifiés.

Propriétés

CanRead	Obtient une valeur Boolean qui indique si le flux sous-jacent est accessible en lecture.
CanSeek	Obtient une valeur Boolean qui indique si le flux sous-jacent peut faire l'objet d'une recherche.
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 ce AuthenticatedStream pour envoyer et recevoir des 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 ce NegotiateStream utilise le chiffrement de données.
IsMutuallyAuthenticated	Obtient une valeur Boolean qui indique si le serveur et le client ont tous les deux été authentifiés.
IsServer	Obtient une valeur Boolean qui indique si le côté local de la connexion utilisée par ce NegotiateStream a été authentifié comme serveur.
IsSigned	Obtient une valeur Boolean qui indique si les données envoyées à l'aide de ce flux sont signées.
LeaveInnerStreamOpen	Obtient une valeur indiquant si le flux utilisé par ce AuthenticatedStream pour envoyer et recevoir des 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 reste bloquée en attendant des données.
RemoteIdentity	Obtient des informations à propos de l'identité du tiers distant qui partage ce flux authentifié.
WriteTimeout	Obtient ou définit la durée pendant laquelle une opération d'écriture reste bloquée en attendant 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 du client, 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 options d'authentification et les informations d'identification spécifiées.
AuthenticateAsClientAsync()	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'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 sous forme d'opération asynchrone. Le processus d'authentification utilise les informations d'identification du client, 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 sous forme d'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 sous forme d'opération asynchrone. Le processus d'authentification utilise les options d'authentification et les informations d'identification 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ées.
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 options d'authentification et les informations d'identification du serveur spécifiées.
AuthenticateAsServerAsync()	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'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 sous forme d'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ées.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone. Le processus d'authentification utilise les options d'authentification et les informations d'identification du serveur spécifiées.
BeginAuthenticateAsClient(AsyncCallback, Object)	Appelé par les clients pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur. Cette méthode ne provoque pas de blocage.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Appelé par les clients pour commencer une opération asynchrone d'authentification du client, et éventuellement du 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 provoque pas de blocage.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Appelé par les clients pour commencer une opération asynchrone d'authentification du client, et éventuellement du 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 provoque pas de blocage.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Appelé par les clients pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur. Le processus d'authentification utilise les informations d'identification spécifiées. Cette méthode ne provoque pas de blocage.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Appelé par les clients pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur. Le processus d'authentification utilise les options d'authentification et les informations d'identification spécifiées. Cette méthode ne provoque pas de blocage.
BeginAuthenticateAsServer(AsyncCallback, Object)	Appelé par les serveurs pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur. Cette méthode ne provoque pas de blocage.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)	Appelé par les serveurs pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur. Le processus d'authentification utilise la stratégie de protection étendue spécifiée. Cette méthode ne provoque pas de blocage.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Appelé par les serveurs pour commencer une opération asynchrone d'authentification du client, et éventuellement du 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ées. Cette méthode ne provoque pas de blocage.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Appelé par les serveurs pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur. Le processus d'authentification utilise les options d'authentification et les informations d'identification du serveur spécifiées. Cette méthode ne provoque pas de blocage.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération de lecture asynchrone qui lit des 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 des Bytes de la mémoire tampon spécifiée vers le flux.
Close()	Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci. Au lieu d'appeler cette méthode, assurez-vous 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 tous les octets du flux actuel et les écrit dans un autre flux, en utilisant 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 façon asynchrone tous 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 façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant 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 tous les octets du flux actuel et les écrit dans un autre flux, en utilisant 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 façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant 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 contenant toutes les informations appropriées requises pour générer un proxy permettant de 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 Stream. (Hérité de Stream)
Dispose(Boolean)	Libère les ressources non managées utilisées par NegotiateStream et libère éventuellement les ressources managées.
DisposeAsync()	Libère de façon asynchrone les ressources non managées et managées utilisées par NegotiateStream.
EndAuthenticateAsClient(IAsyncResult)	Termine une opération d'authentification du client asynchrone en attente qui a été démarrée avec un appel à BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Termine une opération d'authentification du 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()	Provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent.
FlushAsync()	Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. (Hérité de Stream)
FlushAsync(CancellationToken)	Écrit de manière asynchrone des données mises en mémoire tampon sur l’appareil sous-jacent.
GetHashCode()	Fait office 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 en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetType()	Obtient le 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 Object actuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
ObjectInvariant()	Obsolète. Assure 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 remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. (Hérité de Stream)
ReadAsync(Byte[], Int32, Int32)	Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. (Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lit des données de manière asynchrone dans ce flux et les stocke dans le tableau spécifié.
ReadAsync(Memory<Byte>, CancellationToken)	Lit des données de manière asynchrone dans 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 manière asynchrone au moins un nombre minimal d’octets 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)
ReadByte()	Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte. (Hérité de Stream)
ReadExactly(Byte[], Int32, Int32)	Lit le 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 manière asynchrone le nombre d’octets count 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 de l'offset spécifiés.
Write(ReadOnlySpan<Byte>)	En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du 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 le flux du nombre d'octets écrits. (Hérité de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Écrit de manière asynchrone le nombre spécifié de Bytes dans le flux sous-jacent.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Écrit 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 d'un octet la position dans le flux. (Hérité de Stream)

Méthodes d’extension

ConfigureAwait(IAsyncDisposable, Boolean)

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

Voir aussi

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