NegotiateStream Classe

Referência

Definição

Namespace:: System.Net.Security

Assembly:: System.Net.Security.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Fornece um fluxo que usa o protocolo de segurança Negotiate para autenticar o cliente e, opcionalmente, o servidor, em comunicações entre o cliente e o servidor.

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

public class NegotiateStream : System.Net.Security.AuthenticatedStream

[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public class NegotiateStream : System.Net.Security.AuthenticatedStream

type NegotiateStream = class
    inherit AuthenticatedStream

[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
type NegotiateStream = class
    inherit AuthenticatedStream

Public Class NegotiateStream
Inherits AuthenticatedStream

Herança: Object

Stream

AuthenticatedStream
NegotiateStream

Herança: Object

MarshalByRefObject

Stream

AuthenticatedStream
NegotiateStream

Atributos: UnsupportedOSPlatformAttribute

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 NegotiateStream classe para autenticação e para ajudar a proteger as 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 AuthenticateAsClient síncronos, que bloqueiam até que a autenticação seja concluída ou os métodos assíncronos BeginAuthenticateAsClient , que não bloqueiam enquanto aguardam a conclusão da autenticação. Os servidores solicitam autenticação usando os métodos AuthenticateAsServer síncronos ou assíncronos BeginAuthenticateAsServer . O cliente e, opcionalmente, o servidor, são autenticados usando o protocolo de segurança Negotiate. O protocolo Kerberos será usado para autenticação se o cliente e o servidor derem suporte a ele; caso contrário, NTLM é usado. A NegotiateStream classe executa a autenticação usando o SSPI (Security Support Provider Interface).

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

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

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

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

Construtores

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

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 é pesquisável.
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 este AuthenticatedStream para envio e recebimento de 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 são assinados.
LeaveInnerStreamOpen	Obtém a indicação de se o fluxo usado por este AuthenticatedStream para envio e recebimento de 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 é bloqueada aguardando dados.
RemoteIdentity	Obtém informações sobre a identidade da parte remota compartilhando este fluxo autenticado.
WriteTimeout	Obtém ou define a quantidade de tempo pela qual uma operação de gravação fica bloqueada aguardando dados.

Métodos

AuthenticateAsClient()	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de 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 de cliente-servidor. O processo de autenticação usa as credenciais especificadas, as opções de autenticação e a associação de canal.
AuthenticateAsClient(NetworkCredential, String)	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de 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 de cliente-servidor. O processo de autenticação usa as credenciais e as opções de autenticação especificadas.
AuthenticateAsClientAsync()	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de 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 por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona. O processo de autenticação usa as credenciais especificadas, as opções de autenticação e a associação de canal.
AuthenticateAsClientAsync(NetworkCredential, String)	Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de 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 por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de 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 de cliente-servidor.
AuthenticateAsServer(ExtendedProtectionPolicy)	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de 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 de cliente-servidor. O processo de autenticação usa as credenciais de servidor especificadas, as opções de autenticação e a política de proteção estendida.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor. O processo de autenticação usa as opções de autenticação e credenciais de servidor especificadas.
AuthenticateAsServerAsync()	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de 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 de 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 de cliente-servidor como uma operação assíncrona. O processo de autenticação usa as credenciais de servidor especificadas, as opções de autenticação e a política de proteção estendida.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona. O processo de autenticação usa as opções de autenticação e credenciais de servidor especificadas.
BeginAuthenticateAsClient(AsyncCallback, Object)	Chamado por 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 bloqueia.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Chamado por 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 a associação de canal especificadas. Esse método não bloqueia.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Chamado por 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 a credencial especificada, as opções de autenticação e a associação de canal. Esse método não bloqueia.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Chamado por 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 bloqueia.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Chamado por 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 bloqueia.
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 de cliente-servidor. Esse método não bloqueia.
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 de cliente-servidor. O processo de autenticação usa a política de proteção estendida especificada. Esse método não bloqueia.
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 de cliente-servidor. O processo de autenticação usa as credenciais de servidor especificadas, as opções de autenticação e a política de proteção estendida. Esse método não bloqueia.
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 de cliente-servidor. O processo de autenticação usa as opções de autenticação e credenciais de servidor especificadas. Esse método não bloqueia.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de leitura assíncrona que lê os dados do fluxo e os armazena na matriz especificada.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de leitura assíncrona. (Considere o uso de ReadAsync(Byte[], Int32, Int32) em seu lugar.) (Herdado de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de gravação assíncrona que grava Bytes do buffer especificado no fluxo.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de gravação assíncrona. (Considere o uso de WriteAsync(Byte[], Int32, Int32) em seu lugar.) (Herdado de Stream)
Close()	Fecha o fluxo atual e libera todos os recursos (como soquetes e identificadores de arquivos) associados ao fluxo atual. Em vez de chamar esse método, verifique se o fluxo é descartado corretamente. (Herdado de Stream)
CopyTo(Stream)	Lê os bytes do fluxo atual e os grava em outro fluxo. (Herdado de Stream)
CopyTo(Stream, Int32)	Lê os bytes do fluxo atual e os grava em outro fluxo usando um tamanho do buffer especificado. (Herdado de Stream)
CopyToAsync(Stream)	Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo. (Herdado de Stream)
CopyToAsync(Stream, CancellationToken)	Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo usando um token de cancelamento especificado. (Herdado de Stream)
CopyToAsync(Stream, Int32)	Lê de maneira assíncrona os bytes do fluxo atual e os grava em outro fluxo usando um tamanho do buffer especificado. (Herdado de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo usando um tamanho do buffer especificado e um token de cancelamento. (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. 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.
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo AuthenticatedStream e opcionalmente libera os recursos gerenciados. (Herdado de AuthenticatedStream)
DisposeAsync()	Libera de forma assíncrona os recursos gerenciados e não gerenciados usados pelo NegotiateStream.
DisposeAsync()	Libera de forma assíncrona os recursos gerenciados e não gerenciados usados pelo AuthenticatedStream. (Herdado de AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)	Encerra uma operação assíncrona de autenticação de cliente pendente iniciada com uma chamada para BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Encerra uma operação assíncrona de autenticação de cliente pendente iniciada com uma chamada para BeginAuthenticateAsServer.
EndRead(IAsyncResult)	Encerra uma operação de leitura assíncrona que foi iniciada com uma chamada para BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndRead(IAsyncResult)	Espera a leitura assíncrona pendente ser concluída. (Considere o uso de ReadAsync(Byte[], Int32, Int32) em seu lugar.) (Herdado de Stream)
EndWrite(IAsyncResult)	Encerra uma operação de gravação assíncrona que foi iniciada com uma chamada para BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Encerra uma operação de gravação assíncrona. (Considere o uso de WriteAsync(Byte[], Int32, Int32) em seu lugar.) (Herdado de Stream)
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
Flush()	Faz com que os dados armazenados em buffer sejam gravados no dispositivo subjacente.
FlushAsync()	Limpa de forma assíncrona todos os buffers nesse fluxo e faz com que os dados armazenados em buffer sejam gravados no dispositivo subjacente. (Herdado de Stream)
FlushAsync(CancellationToken)	Grava de modo assíncrono todos os dados armazenados em buffer no dispositivo subjacente.
FlushAsync(CancellationToken)	Limpa todos os buffers nesse fluxo de forma assíncrona, faz com que os dados armazenados em buffer sejam gravados no dispositivo subjacente e monitora as solicitações de cancelamento. (Herdado de Stream)
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 ciclo de vida para esta 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 para essa instância. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject)
ObjectInvariant()	Obsoleto. Oferece suporte a um Contract. (Herdado de Stream)
Read(Byte[], Int32, Int32)	Lê os dados desse fluxo e o armazena na matriz especificada.
Read(Span<Byte>)	Quando for substituído em uma classe derivada, lê uma sequência de bytes do fluxo atual e avança a posição dentro do fluxo até o número de bytes lidos. (Herdado de Stream)
ReadAsync(Byte[], Int32, Int32)	Lê uma sequência de bytes do fluxo atual de forma assíncrona e avança a posição no fluxo até o número de bytes lidos. (Herdado de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lê os dados de modo assíncrono desse fluxo e os armazena na matriz especificada.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lê de forma assíncrona uma sequência de bytes do fluxo atual, avança a posição no fluxo até o número de bytes lidos e monitora as solicitações de cancelamento. (Herdado de Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Lê dados de modo assíncrono do NegotiateStream e os armazena em um intervalo de memória de bytes como uma operação assíncrona.
ReadAsync(Memory<Byte>, CancellationToken)	Lê de forma assíncrona uma sequência de bytes do fluxo atual, avança a posição no fluxo até o número de bytes lidos e monitora as solicitações de cancelamento. (Herdado de Stream)
ReadByte()	Lê um byte do fluxo e avança a posição no fluxo em um byte ou retorna -1 caso esteja no final do fluxo. (Herdado de Stream)
Seek(Int64, SeekOrigin)	Gera 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)	Grave o número especificado de Bytes no fluxo subjacente usando o buffer e o deslocamento especificados.
Write(ReadOnlySpan<Byte>)	Quando for 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 até o número de bytes gravados. (Herdado de Stream)
WriteAsync(Byte[], Int32, Int32)	Grava assincronamente uma sequência de bytes no fluxo atual e avança a posição atual dentro desse fluxo no número de bytes gravados. (Herdado de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Grava de forma assíncrona o número especificado de Bytes no fluxo subjacente.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Grava uma sequência de bytes no fluxo atual assincronamente, avança a posição atual dentro desse fluxo pelo número de bytes gravados e monitora as solicitações de cancelamento. (Herdado de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Grava de forma assíncrona o número especificado de Bytes no fluxo subjacente.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Grava uma sequência de bytes no fluxo atual assincronamente, avança a posição atual dentro desse fluxo pelo número de bytes gravados e monitora as solicitações de cancelamento. (Herdado de Stream)
WriteByte(Byte)	Grava um byte na posição atual no fluxo e avança a posição dentro no fluxo em um byte. (Herdado de Stream)

Métodos de Extensão

ConfigureAwait(IAsyncDisposable, Boolean)

Configura como as esperas nas tarefas retornadas de um descartável assíncrono são realizadas.

Aplica-se a

Confira também

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