NegotiateStream Clase

Definición

Espacio de nombres:

System.Net.Security

Ensamblado:

System.Net.Security.dll

Source:

NegotiateStream.cs

Proporciona una secuencia que usa el protocolo de seguridad Negotiate para autenticar al cliente y, opcionalmente, el servidor, en la comunicación de cliente-servidor.

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

Herencia

Object

MarshalByRefObject

Stream

AuthenticatedStream

NegotiateStream

Ejemplos

En el ejemplo siguiente se muestra el lado cliente de una conexión de cliente-servidor que usa el NegotiateStream. El cliente autentica y envía un mensaje al servidor de forma asincrónica.

#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

En el ejemplo de código siguiente se muestra el lado servidor de una conexión cliente-servidor que usa el NegotiateStream para autenticar al cliente y leer un mensaje enviado por el cliente.

#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(); }
        }
    }
}

Comentarios

Use la clase NegotiateStream para la autenticación y para ayudar a proteger la información transmitida entre un cliente y un servidor. Con NegotiateStream, puede hacer lo siguiente.

• Envíe las credenciales del cliente al servidor para suplantación o delegación.

• Solicitar autenticación del servidor.

• Cifre o firme los datos antes de transmitirlos.

La autenticación debe realizarse antes de transmitir información. Los clientes solicitan autenticación mediante los métodos de AuthenticateAsClient sincrónicos, que bloquean hasta que se completa la autenticación o los métodos de BeginAuthenticateAsClient asincrónicos, que no se bloquean mientras esperan a que se complete la autenticación. Los servidores solicitan autenticación mediante los métodos de BeginAuthenticateAsServer sincrónicos AuthenticateAsServer o asincrónicos. El cliente y, opcionalmente, el servidor, se autentica mediante el protocolo de seguridad Negotiate. El protocolo Kerberos se usa para la autenticación si tanto el cliente como el servidor lo admiten; De lo contrario, se usa NTLM. La clase NegotiateStream realiza la autenticación mediante la interfaz del proveedor de soporte técnico de seguridad (SSPI).

Cuando la autenticación se realiza correctamente, debe comprobar las propiedades IsEncrypted y IsSigned para determinar qué servicios de seguridad usará el NegotiateStream para ayudar a proteger los datos durante la transmisión. Compruebe la propiedad IsMutuallyAuthenticated para determinar si se produjo la autenticación mutua. Puede obtener información sobre el cliente remoto o el servidor mediante la propiedad RemoteIdentity.

Si se produce un error en la autenticación, recibirá un AuthenticationException o un InvalidCredentialException. En este caso, puede volver a intentar la autenticación con una credencial diferente.

Los datos se envían mediante los métodos de Write sincrónicos o asincrónicos BeginWrite o WriteAsync. Los datos se reciben mediante los métodos de Read sincrónicos o asincrónicos ReadAsync o BeginRead. Si los servicios de seguridad como el cifrado o la firma están habilitados, estos se aplican automáticamente a los datos mediante el NegotiateStream.

El NegotiateStream transmite datos mediante una secuencia que se proporciona al crear el NegotiateStream. Al proporcionar esta secuencia subyacente, tiene la opción de especificar si el cierre de la NegotiateStream también cierra la secuencia subyacente.

Constructores

NegotiateStream(Stream)	Inicializa una nueva instancia de la clase NegotiateStream mediante el Streamespecificado.
NegotiateStream(Stream, Boolean)	Inicializa una nueva instancia de la clase NegotiateStream mediante el comportamiento de cierre de flujo y Stream especificados.

Propiedades

CanRead	Obtiene un Boolean valor que indica si la secuencia subyacente es legible.
CanSeek	Obtiene un valor Boolean que indica si se puede buscar la secuencia subyacente.
CanTimeout	Obtiene un valor Boolean que indica si la secuencia subyacente admite tiempos de espera.
CanWrite	Obtiene un valor de Boolean que indica si la secuencia subyacente se puede escribir.
ImpersonationLevel	Obtiene un valor que indica cómo el servidor puede usar las credenciales del cliente.
InnerStream	Obtiene la secuencia usada por este AuthenticatedStream para enviar y recibir datos. (Heredado de AuthenticatedStream)
IsAuthenticated	Obtiene un valor de Boolean que indica si la autenticación se realizó correctamente.
IsEncrypted	Obtiene un valor Boolean que indica si este NegotiateStream usa el cifrado de datos.
IsMutuallyAuthenticated	Obtiene un valor de Boolean que indica si el servidor y el cliente se han autenticado.
IsServer	Obtiene un Boolean valor que indica si el lado local de la conexión utilizada por este NegotiateStream se autenticó como servidor.
IsSigned	Obtiene un valor de Boolean que indica si los datos enviados mediante esta secuencia están firmados.
LeaveInnerStreamOpen	Obtiene si la secuencia usada por este AuthenticatedStream para enviar y recibir datos se ha dejado abierta. (Heredado de AuthenticatedStream)
Length	Obtiene la longitud de la secuencia subyacente.
Position	Obtiene o establece la posición actual en la secuencia subyacente.
ReadTimeout	Obtiene o establece la cantidad de tiempo que una operación de lectura bloquea la espera de datos.
RemoteIdentity	Obtiene información sobre la identidad del usuario remoto que comparte esta secuencia autenticada.
WriteTimeout	Obtiene o establece la cantidad de tiempo que una operación de escritura bloquea la espera de datos.

Métodos

AuthenticateAsClient()	Llamado por los clientes para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	Llamado por los clientes para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa la credencial de cliente especificada y el enlace de canal.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Llamado por los clientes para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa las credenciales, las opciones de autenticación y el enlace de canal especificados.
AuthenticateAsClient(NetworkCredential, String)	Llamado por los clientes para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa la credencial de cliente especificada.
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Llamado por los clientes para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa las credenciales y las opciones de autenticación especificadas.
AuthenticateAsClientAsync()	Llamado por los clientes para autenticar al cliente y, opcionalmente, el servidor, en una conexión cliente-servidor como una operación asincrónica.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Llamado por los clientes para autenticar al cliente y, opcionalmente, el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación usa la credencial de cliente especificada y el enlace de canal.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Llamado por los clientes para autenticar al cliente y, opcionalmente, el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación usa las credenciales, las opciones de autenticación y el enlace de canal especificados.
AuthenticateAsClientAsync(NetworkCredential, String)	Llamado por los clientes para autenticar al cliente y, opcionalmente, el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación usa la credencial de cliente especificada.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Llamado por los clientes para autenticar al cliente y, opcionalmente, el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación usa las credenciales y las opciones de autenticación especificadas.
AuthenticateAsServer()	Llamado por los servidores para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor.
AuthenticateAsServer(ExtendedProtectionPolicy)	Llamado por los servidores para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa la directiva de protección ampliada especificada.
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Llamado por los servidores para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa las credenciales de servidor, las opciones de autenticación y la directiva de protección ampliada especificadas.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Llamado por los servidores para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa las credenciales de servidor y las opciones de autenticación especificadas.
AuthenticateAsServerAsync()	Llamado por los servidores para autenticar al cliente y, opcionalmente, el servidor, en una conexión cliente-servidor como una operación asincrónica.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	Llamado por los servidores para autenticar al cliente y, opcionalmente, el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación usa la directiva de protección ampliada especificada.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Llamado por los servidores para autenticar al cliente y, opcionalmente, el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación usa las credenciales de servidor, las opciones de autenticación y la directiva de protección ampliada especificadas.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Llamado por los servidores para autenticar al cliente y, opcionalmente, el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación usa las credenciales de servidor y las opciones de autenticación especificadas.
BeginAuthenticateAsClient(AsyncCallback, Object)	Llamado por los clientes para iniciar una operación asincrónica para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. Este método no se bloquea.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Llamado por los clientes para iniciar una operación asincrónica para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa las credenciales y el enlace de canal especificados. Este método no se bloquea.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Llamado por los clientes para iniciar una operación asincrónica para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa las credenciales, las opciones de autenticación y el enlace de canal especificados. Este método no se bloquea.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Llamado por los clientes para iniciar una operación asincrónica para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa las credenciales especificadas. Este método no se bloquea.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Llamado por los clientes para iniciar una operación asincrónica para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa las credenciales y las opciones de autenticación especificadas. Este método no se bloquea.
BeginAuthenticateAsServer(AsyncCallback, Object)	Llamado por los servidores para iniciar una operación asincrónica para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. Este método no se bloquea.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)	Llamado por los servidores para iniciar una operación asincrónica para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa la directiva de protección ampliada especificada. Este método no se bloquea.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Llamado por los servidores para iniciar una operación asincrónica para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa las credenciales de servidor, las opciones de autenticación y la directiva de protección ampliada especificadas. Este método no se bloquea.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Llamado por los servidores para iniciar una operación asincrónica para autenticar al cliente y, opcionalmente, el servidor, en una conexión de cliente-servidor. El proceso de autenticación usa las credenciales de servidor y las opciones de autenticación especificadas. Este método no se bloquea.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia una operación de lectura asincrónica que lee datos de la secuencia y los almacena en la matriz especificada.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Comienza una operación de escritura asincrónica que escribe Bytes del búfer especificado en la secuencia.
Close()	Cierra la secuencia actual y libera los recursos (como sockets y identificadores de archivo) asociados a la secuencia actual. En lugar de llamar a este método, asegúrese de que la secuencia se elimina correctamente. (Heredado de Stream)
CopyTo(Stream)	Lee los bytes de la secuencia actual y los escribe en otra secuencia. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream)
CopyTo(Stream, Int32)	Lee los bytes de la secuencia actual y los escribe en otra secuencia mediante un tamaño de búfer especificado. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream)
CopyToAsync(Stream)	Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream)
CopyToAsync(Stream, CancellationToken)	Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, mediante un token de cancelación especificado. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream)
CopyToAsync(Stream, Int32)	Lee de forma asincrónica los bytes de la secuencia actual y los escribe en otra secuencia mediante un tamaño de búfer especificado. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, mediante un tamaño de búfer y un token de cancelación especificados. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream)
CreateObjRef(Type)	Crea un objeto que contiene toda la información pertinente necesaria para generar un proxy usado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
CreateWaitHandle()	Obsoletos. Asigna un objeto WaitHandle. (Heredado de Stream)
Dispose()	Libera todos los recursos usados por el Stream. (Heredado de Stream)
Dispose(Boolean)	Libera los recursos no administrados usados por el NegotiateStream y, opcionalmente, libera los recursos administrados.
DisposeAsync()	Libera de forma asincrónica los recursos no administrados y administrados usados por el NegotiateStream.
EndAuthenticateAsClient(IAsyncResult)	Finaliza una operación de autenticación de cliente asincrónica pendiente que se inició con una llamada a BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Finaliza una operación de autenticación de cliente asincrónica pendiente que se inició con una llamada a BeginAuthenticateAsServer.
EndRead(IAsyncResult)	Finaliza una operación de lectura asincrónica que se inició con una llamada a BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Finaliza una operación de escritura asincrónica que se inició con una llamada a BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Determina si el objeto especificado es igual al objeto actual. (Heredado de Object)
Flush()	Hace que los datos almacenados en búfer se escriban en el dispositivo subyacente.
FlushAsync()	Borra de forma asincrónica todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. (Heredado de Stream)
FlushAsync(CancellationToken)	Escribe de forma asincrónica los datos almacenados en búfer en el dispositivo subyacente.
GetHashCode()	Actúa como función hash predeterminada. (Heredado de Object)
GetLifetimeService()	Obsoletos. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
InitializeLifetimeService()	Obsoletos. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
ObjectInvariant()	Obsoletos. Proporciona compatibilidad con un Contract. (Heredado de Stream)
Read(Byte[], Int32, Int32)	Lee los datos de esta secuencia y los almacena en la matriz especificada.
Read(Span<Byte>)	Cuando se reemplaza en una clase derivada, lee una secuencia de bytes de la secuencia actual y avanza la posición dentro de la secuencia por el número de bytes leídos. (Heredado de Stream)
ReadAsync(Byte[], Int32, Int32)	Lee de forma asincrónica una secuencia de bytes de la secuencia actual y avanza la posición dentro de la secuencia por el número de bytes leídos. (Heredado de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lee los datos de forma asincrónica de esta secuencia y los almacena en la matriz especificada.
ReadAsync(Memory<Byte>, CancellationToken)	Lee los datos de forma asincrónica desde el NegotiateStream y los almacena en un intervalo de memoria de bytes como una operación asincrónica.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Lee al menos un número mínimo de bytes de la secuencia actual y avanza la posición dentro de la secuencia por el número de bytes leídos. (Heredado de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Lee de forma asincrónica al menos un número mínimo de bytes de la secuencia actual, avanza la posición dentro de la secuencia por el número de bytes leídos y supervisa las solicitudes de cancelación. (Heredado de Stream)
ReadByte()	Lee un byte de la secuencia y avanza la posición dentro de la secuencia por un byte, o devuelve -1 si está al final de la secuencia. (Heredado de Stream)
ReadExactly(Byte[], Int32, Int32)	Lee count número de bytes de la secuencia actual y avanza la posición dentro de la secuencia. (Heredado de Stream)
ReadExactly(Span<Byte>)	Lee bytes de la secuencia actual y avanza la posición dentro de la secuencia hasta que se rellena el buffer. (Heredado de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Lee de forma asincrónica count número de bytes de la secuencia actual, avanza la posición dentro de la secuencia y supervisa las solicitudes de cancelación. (Heredado de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Lee de forma asincrónica bytes de la secuencia actual, avanza la posición dentro de la secuencia hasta que se rellena el buffer y supervisa las solicitudes de cancelación. (Heredado de Stream)
Seek(Int64, SeekOrigin)	Produce NotSupportedException.
SetLength(Int64)	Establece la longitud de la secuencia subyacente.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
Write(Byte[], Int32, Int32)	Escriba el número especificado de Bytes en la secuencia subyacente mediante el búfer y el desplazamiento especificados.
Write(ReadOnlySpan<Byte>)	Cuando se reemplaza en una clase derivada, escribe una secuencia de bytes en la secuencia actual y avanza la posición actual dentro de esta secuencia por el número de bytes escritos. (Heredado de Stream)
WriteAsync(Byte[], Int32, Int32)	Escribe de forma asincrónica una secuencia de bytes en la secuencia actual y avanza la posición actual dentro de esta secuencia por el número de bytes escritos. (Heredado de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Escriba de forma asincrónica el número especificado de Bytes en la secuencia subyacente.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Escriba de forma asincrónica el número especificado de Bytes en la secuencia subyacente.
WriteByte(Byte)	Escribe un byte en la posición actual de la secuencia y avanza la posición dentro de la secuencia por un byte. (Heredado de Stream)

Métodos de extensión

CopyToAsync(Stream, PipeWriter, CancellationToken)	Lee asincrónicamente los bytes de la Stream y los escribe en el PipeWriterespecificado mediante un token de cancelación.
ConfigureAwait(IAsyncDisposable, Boolean)	Configura cómo se realizarán las esperas en las tareas devueltas desde un descartable asincrónico.

Consulte también

• cambios en la autenticación NTLM para HTTPWebRequest en la versión 3.5 SP1