NegotiateStream Classe

Definição

Namespace:

System.Net.Security

Assembly:

System.Net.Security.dll

Origem:

NegotiateStream.cs

Fornece um fluxo que usa o protocolo de segurança Negotiate para autenticar o cliente e, opcionalmente, o servidor, na comunicação 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

Herança

Object

MarshalByRefObject

Stream

AuthenticatedStream

NegotiateStream

Exemplos

O exemplo a seguir demonstra o lado do cliente de uma conexão cliente-servidor que usa o NegotiateStream. O cliente autentica e envia uma mensagem para o servidor de forma assíncrona.

#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

O exemplo de código a seguir demonstra o lado do servidor de uma conexão cliente-servidor que usa o NegotiateStream para autenticar o cliente e ler uma mensagem enviada pelo 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(); }
        }
    }
}

Comentários

Use a classe NegotiateStream para autenticação e para ajudar a proteger informações transmitidas entre um cliente e um servidor. Usando NegotiateStream, você pode fazer o seguinte.

• Envie as credenciais do cliente para o servidor para Representação ou Delegação.

• Solicitar autenticação do servidor.

• Criptografar e/ou assinar dados antes de transmiti-los.

A autenticação deve ser executada antes de transmitir informações. Os clientes solicitam autenticação usando os métodos de AuthenticateAsClient síncronos, que bloqueiam até que a autenticação seja concluída ou os métodos de BeginAuthenticateAsClient assíncronos, que não bloqueiam enquanto aguardam a conclusão da autenticação. Os servidores solicitam autenticação usando os métodos de BeginAuthenticateAsServer síncronos ou AuthenticateAsServer assíncronos. O cliente e, opcionalmente, o servidor, é autenticado usando o protocolo de segurança Negotiate. O protocolo Kerberos é usado para autenticação se o cliente e o servidor dão suporte a ele; caso contrário, NTLM é usado. A classe NegotiateStream executa a autenticação usando a SSPI (Interface do Provedor de Suporte de Segurança).

Quando a autenticação for bem-sucedida, você deverá verificar as propriedades IsEncrypted e IsSigned para determinar quais serviços de segurança serão usados pelo NegotiateStream para ajudar a proteger seus dados durante a transmissão. Verifique a propriedade IsMutuallyAuthenticated para determinar se a autenticação mútua ocorreu. Você pode obter informações sobre o cliente ou servidor remoto usando a propriedade RemoteIdentity.

Se a autenticação falhar, você receberá um AuthenticationException ou um InvalidCredentialException. Nesse caso, você pode repetir a autenticação com uma credencial diferente.

Você envia dados usando os métodos Write síncronos ou assíncronos BeginWrite ou WriteAsync. Você recebe dados usando os métodos síncronos Read ou assíncronos ReadAsync ou BeginRead. Se os serviços de segurança, como criptografia ou assinatura, estiverem habilitados, eles serão aplicados automaticamente aos seus dados pelo NegotiateStream.

O NegotiateStream transmite dados usando um fluxo que você fornece ao criar o NegotiateStream. Ao fornecer esse fluxo subjacente, você tem a opção de especificar se o fechamento do NegotiateStream também fecha o fluxo subjacente.

Construtores

NegotiateStream(Stream)	Inicializa uma nova instância da classe NegotiateStream usando o Streamespecificado.
NegotiateStream(Stream, Boolean)	Inicializa uma nova instância da classe NegotiateStream usando o comportamento de fechamento de fluxo e Stream especificado.

Propriedades

CanRead	Obtém um valor Boolean que indica se o fluxo subjacente é legível.
CanSeek	Obtém um valor Boolean que indica se o fluxo subjacente é procurado.
CanTimeout	Obtém um valor Boolean que indica se o fluxo subjacente dá suporte a tempos limite.
CanWrite	Obtém um valor Boolean que indica se o fluxo subjacente é gravável.
ImpersonationLevel	Obtém um valor que indica como o servidor pode usar as credenciais do cliente.
InnerStream	Obtém o fluxo usado por esse AuthenticatedStream para enviar e receber dados. (Herdado de AuthenticatedStream)
IsAuthenticated	Obtém um valor Boolean que indica se a autenticação foi bem-sucedida.
IsEncrypted	Obtém um valor Boolean que indica se esse NegotiateStream usa criptografia de dados.
IsMutuallyAuthenticated	Obtém um valor Boolean que indica se o servidor e o cliente foram autenticados.
IsServer	Obtém um valor Boolean que indica se o lado local da conexão usada por esse NegotiateStream foi autenticado como o servidor.
IsSigned	Obtém um valor Boolean que indica se os dados enviados usando esse fluxo estão assinados.
LeaveInnerStreamOpen	Obtém se o fluxo usado por esse AuthenticatedStream para enviar e receber dados foi deixado aberto. (Herdado de AuthenticatedStream)
Length	Obtém o comprimento do fluxo subjacente.
Position	Obtém ou define a posição atual no fluxo subjacente.
ReadTimeout	Obtém ou define a quantidade de tempo que uma operação de leitura bloqueia à espera de dados.
RemoteIdentity	Obtém informações sobre a identidade da parte remota que compartilha esse fluxo autenticado.
WriteTimeout	Obtém ou define a quantidade de tempo que uma operação de gravação bloqueia aguardando dados.

Métodos

AuthenticateAsClient()	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa a credencial do cliente especificada e a associação de canal.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa a credencial, as opções de autenticação e a associação de canal especificadas.
AuthenticateAsClient(NetworkCredential, String)	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa a credencial de cliente especificada.
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa as credenciais e as opções de autenticação especificadas.
AuthenticateAsClientAsync()	Chamado pelos clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor como uma operação assíncrona.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Chamado pelos clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa a credencial do cliente especificada e a associação de canal.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Chamado pelos clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa a credencial, as opções de autenticação e a associação de canal especificadas.
AuthenticateAsClientAsync(NetworkCredential, String)	Chamado pelos clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa a credencial de cliente especificada.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Chamado pelos clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa as credenciais e as opções de autenticação especificadas.
AuthenticateAsServer()	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor.
AuthenticateAsServer(ExtendedProtectionPolicy)	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa a política de proteção estendida especificada.
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa as credenciais do servidor, as opções de autenticação e a política de proteção estendida especificadas.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa as credenciais de servidor especificadas e as opções de autenticação.
AuthenticateAsServerAsync()	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor como uma operação assíncrona.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa a política de proteção estendida especificada.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa as credenciais do servidor, as opções de autenticação e a política de proteção estendida especificadas.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor como uma operação assíncrona. O processo de autenticação usa as credenciais de servidor especificadas e as opções de autenticação.
BeginAuthenticateAsClient(AsyncCallback, Object)	Chamado pelos clientes para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. Esse método não é bloqueado.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Chamado pelos clientes para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa as credenciais especificadas e a associação de canal. Esse método não é bloqueado.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Chamado pelos clientes para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa as credenciais, as opções de autenticação e a associação de canal especificadas. Esse método não é bloqueado.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Chamado pelos clientes para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa as credenciais especificadas. Esse método não é bloqueado.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Chamado pelos clientes para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa as credenciais e as opções de autenticação especificadas. Esse método não é bloqueado.
BeginAuthenticateAsServer(AsyncCallback, Object)	Chamado por servidores para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. Esse método não é bloqueado.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)	Chamado por servidores para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa a política de proteção estendida especificada. Esse método não é bloqueado.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Chamado por servidores para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa as credenciais do servidor, as opções de autenticação e a política de proteção estendida especificadas. Esse método não é bloqueado.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Chamado por servidores para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão cliente-servidor. O processo de autenticação usa as credenciais de servidor especificadas e as opções de autenticação. Esse método não é bloqueado.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de leitura assíncrona que lê dados do fluxo e os armazena na matriz especificada.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de gravação assíncrona que grava Bytes do buffer especificado no fluxo.
Close()	Fecha o fluxo atual e libera todos os recursos (como soquetes e identificadores de arquivo) associados ao fluxo atual. Em vez de chamar esse método, verifique se o fluxo foi descartado corretamente. (Herdado de Stream)
CopyTo(Stream)	Lê os bytes do fluxo atual e os grava em outro fluxo. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyTo(Stream, Int32)	Lê os bytes do fluxo atual e os grava em outro fluxo, usando um tamanho de buffer especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream)	Lê assíncronamente os bytes do fluxo atual e os grava em outro fluxo. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, CancellationToken)	Lê assíncronamente os bytes do fluxo atual e os grava em outro fluxo, usando um token de cancelamento especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, Int32)	Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo, usando um tamanho de buffer especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lê assíncronamente os bytes do fluxo atual e os grava em outro fluxo, usando um token de cancelamento e tamanho de buffer especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CreateObjRef(Type)	Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject)
CreateWaitHandle()	Obsoleto. Aloca um objeto WaitHandle. (Herdado de Stream)
Dispose()	Libera todos os recursos usados pelo Stream. (Herdado de Stream)
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo NegotiateStream e, opcionalmente, libera os recursos gerenciados.
DisposeAsync()	Libera de forma assíncrona os recursos não gerenciados e gerenciados usados pelo NegotiateStream.
EndAuthenticateAsClient(IAsyncResult)	Encerra uma operação de autenticação de cliente assíncrona pendente iniciada com uma chamada para BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Encerra uma operação de autenticação de cliente assíncrona pendente iniciada com uma chamada para BeginAuthenticateAsServer.
EndRead(IAsyncResult)	Encerra uma operação de leitura assíncrona iniciada com uma chamada para BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Encerra uma operação de gravação assíncrona iniciada com uma chamada para BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
Flush()	Faz com que todos os dados em buffer sejam gravados no dispositivo subjacente.
FlushAsync()	Limpa de forma assíncrona todos os buffers para esse fluxo e faz com que todos os dados em buffer sejam gravados no dispositivo subjacente. (Herdado de Stream)
FlushAsync(CancellationToken)	Grava de forma assíncrona todos os dados em buffer no dispositivo subjacente.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLifetimeService()	Obsoleto. Recupera o objeto de serviço de tempo de vida atual que controla a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
InitializeLifetimeService()	Obsoleto. Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida dessa instância. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject)
ObjectInvariant()	Obsoleto. Fornece suporte para um Contract. (Herdado de Stream)
Read(Byte[], Int32, Int32)	Lê dados desse fluxo e os armazena na matriz especificada.
Read(Span<Byte>)	Quando substituído em uma classe derivada, lê uma sequência de bytes do fluxo atual e avança a posição dentro do fluxo pelo número de bytes lidos. (Herdado de Stream)
ReadAsync(Byte[], Int32, Int32)	Lê de forma assíncrona uma sequência de bytes do fluxo atual e avança a posição dentro do fluxo pelo número de bytes lidos. (Herdado de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lê dados de forma assíncrona desse fluxo e os armazena na matriz especificada.
ReadAsync(Memory<Byte>, CancellationToken)	Lê dados de forma assíncrona do NegotiateStream e os armazena em um intervalo de memória de bytes como uma operação assíncrona.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Lê pelo menos um número mínimo de bytes do fluxo atual e avança a posição dentro do fluxo pelo número de bytes lidos. (Herdado de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Lê de forma assíncrona pelo menos um número mínimo de bytes do fluxo atual, avança a posição dentro do fluxo pelo número de bytes lidos e monitora solicitações de cancelamento. (Herdado de Stream)
ReadByte()	Lê um byte do fluxo e avança a posição dentro do fluxo por um byte ou retorna -1 se estiver no final do fluxo. (Herdado de Stream)
ReadExactly(Byte[], Int32, Int32)	Lê count número de bytes do fluxo atual e avança a posição dentro do fluxo. (Herdado de Stream)
ReadExactly(Span<Byte>)	Lê bytes do fluxo atual e avança a posição dentro do fluxo até que a buffer seja preenchida. (Herdado de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Lê de forma assíncrona count número de bytes do fluxo atual, avança a posição dentro do fluxo e monitora solicitações de cancelamento. (Herdado de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Lê bytes de forma assíncrona do fluxo atual, avança a posição dentro do fluxo até que o buffer seja preenchido e monitore as solicitações de cancelamento. (Herdado de Stream)
Seek(Int64, SeekOrigin)	Lança NotSupportedException.
SetLength(Int64)	Define o comprimento do fluxo subjacente.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
Write(Byte[], Int32, Int32)	Escreva o número especificado de Bytes no fluxo subjacente usando o buffer e o deslocamento especificados.
Write(ReadOnlySpan<Byte>)	Quando substituído em uma classe derivada, grava uma sequência de bytes no fluxo atual e avança a posição atual dentro desse fluxo pelo número de bytes gravados. (Herdado de Stream)
WriteAsync(Byte[], Int32, Int32)	Grava de forma assíncrona uma sequência de bytes no fluxo atual e avança a posição atual dentro desse fluxo pelo número de bytes gravados. (Herdado de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Escreva de forma assíncrona o número especificado de Bytes no fluxo subjacente.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Escreva de forma assíncrona o número especificado de Bytes no fluxo subjacente.
WriteByte(Byte)	Grava um byte na posição atual no fluxo e avança a posição dentro do fluxo por um byte. (Herdado de Stream)

Métodos de Extensão

CopyToAsync(Stream, PipeWriter, CancellationToken)	Lê assíncronamente os bytes do Stream e os grava no PipeWriterespecificado usando um token de cancelamento.
ConfigureAwait(IAsyncDisposable, Boolean)	Configura como as esperas nas tarefas retornadas de um descartável assíncrono serão executadas.

Confira também

• alterações na autenticação NTLM para HTTPWebRequest na versão 3.5 SP1