NegotiateStream Klasa

Definicja

Przestrzeń nazw:

System.Net.Security

Zestaw:

System.Net.Security.dll

Źródło:

NegotiateStream.cs

Udostępnia strumień, który używa protokołu zabezpieczeń Negotiate do uwierzytelniania klienta i opcjonalnie serwera w komunikacji klient-serwer.

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

Dziedziczenie

Object

MarshalByRefObject

Stream

AuthenticatedStream

NegotiateStream

Przykłady

W poniższym przykładzie pokazano stronę klienta połączenia klient-serwer, który używa NegotiateStream. Klient uwierzytelnia się i wysyła komunikat do serwera asynchronicznie.

#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

Poniższy przykład kodu przedstawia stronę serwera połączenia klient-serwer, który używa NegotiateStream do uwierzytelniania klienta i odczytywania komunikatu wysłanego przez klienta.

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

Uwagi

Użyj klasy NegotiateStream do uwierzytelniania i, aby ułatwić zabezpieczanie informacji przesyłanych między klientem a serwerem. Korzystając z NegotiateStream, możesz wykonać następujące czynności.

• Wyślij poświadczenia klienta do serwera w celu personifikacji lub delegowania.

• Żądanie uwierzytelniania serwera.

• Szyfruj i/lub podpisz dane przed ich przesłaniem.

Przed przesłaniem informacji należy przeprowadzić uwierzytelnianie. Klienci żądają uwierzytelniania przy użyciu metod synchronicznych AuthenticateAsClient, które blokują się do momentu ukończenia uwierzytelniania lub metod asynchronicznych BeginAuthenticateAsClient, które nie blokują podczas oczekiwania na ukończenie uwierzytelniania. Serwery żądają uwierzytelniania przy użyciu synchronicznych metod AuthenticateAsServer lub asynchronicznych BeginAuthenticateAsServer. Klient i opcjonalnie serwer jest uwierzytelniany przy użyciu protokołu zabezpieczeń Negotiate. Protokół Kerberos jest używany do uwierzytelniania, jeśli zarówno klient, jak i serwer go obsługują; w przeciwnym razie jest używany protokół NTLM. Klasa NegotiateStream wykonuje uwierzytelnianie przy użyciu interfejsu dostawcy obsługi zabezpieczeń (SSPI).

Po pomyślnym uwierzytelnieniu należy sprawdzić IsEncrypted i IsSigned właściwości, aby określić, jakie usługi zabezpieczeń będą używane przez NegotiateStream, aby ułatwić zabezpieczanie danych podczas transmisji. Sprawdź właściwość IsMutuallyAuthenticated, aby określić, czy wystąpiło wzajemne uwierzytelnianie. Informacje o zdalnym kliencie lub serwerze można uzyskać przy użyciu właściwości RemoteIdentity.

Jeśli uwierzytelnianie zakończy się niepowodzeniem, otrzymasz AuthenticationException lub InvalidCredentialException. W takim przypadku można ponowić próbę uwierzytelnienia przy użyciu innego poświadczenia.

Dane są wysyłane przy użyciu synchronicznych metod Write lub asynchronicznych BeginWrite lub WriteAsync. Dane są odbierane przy użyciu synchronicznych metod Read lub asynchronicznych ReadAsync lub BeginRead. Jeśli są włączone usługi zabezpieczeń, takie jak szyfrowanie lub podpisywanie, są one automatycznie stosowane do danych przez NegotiateStream.

NegotiateStream przesyła dane przy użyciu strumienia dostarczanego podczas tworzenia NegotiateStream. Po podaniu tego bazowego strumienia możesz określić, czy zamknięcie NegotiateStream również zamyka bazowy strumień.

Konstruktory

NegotiateStream(Stream)	Inicjuje nowe wystąpienie klasy NegotiateStream przy użyciu określonego Stream.
NegotiateStream(Stream, Boolean)	Inicjuje nowe wystąpienie klasy NegotiateStream przy użyciu określonego zachowania Stream i zamknięcia strumienia.

Właściwości

CanRead	Pobiera wartość Boolean wskazującą, czy źródłowy strumień jest czytelny.
CanSeek	Pobiera wartość Boolean, która wskazuje, czy podstawowy strumień można wyszukiwać.
CanTimeout	Pobiera wartość Boolean wskazującą, czy bazowy strumień obsługuje limity czasu.
CanWrite	Pobiera wartość Boolean wskazującą, czy bazowy strumień jest zapisywalny.
ImpersonationLevel	Pobiera wartość wskazującą, jak serwer może używać poświadczeń klienta.
InnerStream	Pobiera strumień używany przez tę AuthenticatedStream do wysyłania i odbierania danych. (Odziedziczone po AuthenticatedStream)
IsAuthenticated	Pobiera wartość Boolean wskazującą, czy uwierzytelnianie zakończyło się pomyślnie.
IsEncrypted	Pobiera wartość Boolean wskazującą, czy ta NegotiateStream używa szyfrowania danych.
IsMutuallyAuthenticated	Pobiera wartość Boolean wskazującą, czy zarówno serwer, jak i klient zostały uwierzytelnione.
IsServer	Pobiera wartość Boolean wskazującą, czy lokalna strona połączenia używanego przez tę NegotiateStream została uwierzytelniona jako serwer.
IsSigned	Pobiera wartość Boolean wskazującą, czy dane wysyłane przy użyciu tego strumienia są podpisane.
LeaveInnerStreamOpen	Pobiera, czy strumień używany przez ten AuthenticatedStream do wysyłania i odbierania danych został otwarty. (Odziedziczone po AuthenticatedStream)
Length	Pobiera długość bazowego strumienia.
Position	Pobiera lub ustawia bieżące położenie w strumieniu bazowym.
ReadTimeout	Pobiera lub ustawia czas, przez jaki operacja odczytu blokuje oczekiwanie na dane.
RemoteIdentity	Pobiera informacje o tożsamości osoby zdalnej współużytkowania tego uwierzytelnionego strumienia.
WriteTimeout	Pobiera lub ustawia czas, przez jaki operacja zapisu blokuje oczekiwanie na dane.

Metody

AuthenticateAsClient()	Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń klienta i powiązania kanału.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń, opcji uwierzytelniania i powiązania kanału.
AuthenticateAsClient(NetworkCredential, String)	Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonego poświadczenia klienta.
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń i opcji uwierzytelniania.
AuthenticateAsClientAsync()	Wywoływana przez klientów w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Wywoływana przez klientów w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonych poświadczeń klienta i powiązania kanału.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Wywoływana przez klientów w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonych poświadczeń, opcji uwierzytelniania i powiązania kanału.
AuthenticateAsClientAsync(NetworkCredential, String)	Wywoływana przez klientów w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonego poświadczenia klienta.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Wywoływana przez klientów w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonych poświadczeń i opcji uwierzytelniania.
AuthenticateAsServer()	Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer.
AuthenticateAsServer(ExtendedProtectionPolicy)	Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych zasad ochrony rozszerzonej.
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer. W procesie uwierzytelniania są używane określone poświadczenia serwera, opcje uwierzytelniania i rozszerzone zasady ochrony.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń serwera i opcji uwierzytelniania.
AuthenticateAsServerAsync()	Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonych zasad ochrony rozszerzonej.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. W procesie uwierzytelniania są używane określone poświadczenia serwera, opcje uwierzytelniania i rozszerzone zasady ochrony.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonych poświadczeń serwera i opcji uwierzytelniania.
BeginAuthenticateAsClient(AsyncCallback, Object)	Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Ta metoda nie blokuje.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń i powiązania kanału. Ta metoda nie blokuje.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń, opcji uwierzytelniania i powiązania kanału. Ta metoda nie blokuje.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń. Ta metoda nie blokuje.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń i opcji uwierzytelniania. Ta metoda nie blokuje.
BeginAuthenticateAsServer(AsyncCallback, Object)	Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Ta metoda nie blokuje.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)	Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych zasad ochrony rozszerzonej. Ta metoda nie blokuje.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. W procesie uwierzytelniania są używane określone poświadczenia serwera, opcje uwierzytelniania i rozszerzone zasady ochrony. Ta metoda nie blokuje.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń serwera i opcji uwierzytelniania. Ta metoda nie blokuje.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Rozpoczyna asynchroniczną operację odczytu, która odczytuje dane ze strumienia i zapisuje je w określonej tablicy.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Rozpoczyna asynchroniczną operację zapisu, która zapisuje Bytes z określonego buforu do strumienia.
Close()	Zamyka bieżący strumień i zwalnia wszystkie zasoby (takie jak gniazda i dojścia plików) skojarzone z bieżącym strumieniem. Zamiast wywoływać tę metodę, upewnij się, że strumień jest prawidłowo usuwany. (Odziedziczone po Stream)
CopyTo(Stream)	Odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CopyTo(Stream, Int32)	Odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CopyToAsync(Stream)	Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CopyToAsync(Stream, CancellationToken)	Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego tokenu anulowania. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CopyToAsync(Stream, Int32)	Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu i tokenu anulowania. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream)
CreateObjRef(Type)	Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym. (Odziedziczone po MarshalByRefObject)
CreateWaitHandle()	Przestarzałe. Przydziela obiekt WaitHandle. (Odziedziczone po Stream)
Dispose()	Zwalnia wszystkie zasoby używane przez Stream. (Odziedziczone po Stream)
Dispose(Boolean)	Zwalnia niezarządzane zasoby używane przez NegotiateStream i opcjonalnie zwalnia zarządzane zasoby.
DisposeAsync()	Asynchronicznie zwalnia niezarządzane i zarządzane zasoby używane przez NegotiateStream.
EndAuthenticateAsClient(IAsyncResult)	Kończy oczekującą operację asynchronicznego uwierzytelniania klienta, która została uruchomiona z wywołaniem BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Kończy oczekującą operację asynchronicznego uwierzytelniania klienta, która została uruchomiona z wywołaniem BeginAuthenticateAsServer.
EndRead(IAsyncResult)	Kończy asynchroniczną operację odczytu, która została uruchomiona z wywołaniem BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Kończy asynchroniczną operację zapisu, która została uruchomiona z wywołaniem BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Określa, czy określony obiekt jest równy bieżącemu obiektowi. (Odziedziczone po Object)
Flush()	Powoduje zapisanie wszystkich buforowanych danych na urządzeniu bazowym.
FlushAsync()	Asynchronicznie czyści wszystkie dla tego strumienia i powoduje zapisanie wszystkich buforowanych danych na urządzeniu bazowym. (Odziedziczone po Stream)
FlushAsync(CancellationToken)	Asynchronicznie zapisuje wszystkie buforowane dane na urządzeniu bazowym.
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetLifetimeService()	Przestarzałe. Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
GetType()	Pobiera Type bieżącego wystąpienia. (Odziedziczone po Object)
InitializeLifetimeService()	Przestarzałe. Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Object. (Odziedziczone po Object)
MemberwiseClone(Boolean)	Tworzy płytkią kopię bieżącego obiektu MarshalByRefObject. (Odziedziczone po MarshalByRefObject)
ObjectInvariant()	Przestarzałe. Zapewnia obsługę Contract. (Odziedziczone po Stream)
Read(Byte[], Int32, Int32)	Odczytuje dane z tego strumienia i przechowuje je w określonej tablicy.
Read(Span<Byte>)	Gdy przesłonięta w klasie pochodnej, odczytuje sekwencję bajtów z bieżącego strumienia i przechodzi pozycję w strumieniu według liczby odczytanych bajtów. (Odziedziczone po Stream)
ReadAsync(Byte[], Int32, Int32)	Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia i rozwija pozycję w strumieniu według liczby odczytanych bajtów. (Odziedziczone po Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Odczytuje dane asynchronicznie z tego strumienia i przechowuje je w określonej tablicy.
ReadAsync(Memory<Byte>, CancellationToken)	Odczytuje dane asynchronicznie z NegotiateStream i przechowuje je w zakresie pamięci bajtów jako operację asynchroniczną.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Odczytuje co najmniej minimalną liczbę bajtów z bieżącego strumienia i rozwija pozycję w strumieniu według liczby odczytanych bajtów. (Odziedziczone po Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Asynchronicznie odczytuje co najmniej minimalną liczbę bajtów z bieżącego strumienia, zwiększa pozycję w strumieniu przez liczbę odczytanych bajtów i monitoruje żądania anulowania. (Odziedziczone po Stream)
ReadByte()	Odczytuje bajt ze strumienia i rozwija pozycję w strumieniu według jednego bajtu lub zwraca -1, jeśli na końcu strumienia. (Odziedziczone po Stream)
ReadExactly(Byte[], Int32, Int32)	Odczytuje count liczbę bajtów z bieżącego strumienia i rozwija pozycję w strumieniu. (Odziedziczone po Stream)
ReadExactly(Span<Byte>)	Odczytuje bajty z bieżącego strumienia i przesuwa pozycję w strumieniu do momentu wypełnienia buffer. (Odziedziczone po Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronicznie odczytuje count liczbę bajtów z bieżącego strumienia, zwiększa pozycję w strumieniu i monitoruje żądania anulowania. (Odziedziczone po Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Asynchronicznie odczytuje bajty z bieżącego strumienia, przechodzi pozycję w strumieniu do momentu wypełnienia buffer i monitoruje żądania anulowania. (Odziedziczone po Stream)
Seek(Int64, SeekOrigin)	Zgłasza NotSupportedException.
SetLength(Int64)	Ustawia długość bazowego strumienia.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
Write(Byte[], Int32, Int32)	Zapisz określoną liczbę Bytes do bazowego strumienia przy użyciu określonego buforu i przesunięcia.
Write(ReadOnlySpan<Byte>)	Po zastąpieniu w klasie pochodnej zapisuje sekwencję bajtów do bieżącego strumienia i przechodzi bieżącą pozycję w tym strumieniu przez liczbę zapisanych bajtów. (Odziedziczone po Stream)
WriteAsync(Byte[], Int32, Int32)	Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia i przechodzi bieżącą pozycję w tym strumieniu przez liczbę zapisanych bajtów. (Odziedziczone po Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Zapisuj asynchronicznie określoną liczbę Bytedo bazowego strumienia.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Zapisuj asynchronicznie określoną liczbę Bytedo bazowego strumienia.
WriteByte(Byte)	Zapisuje bajt do bieżącej pozycji w strumieniu i rozwija pozycję w strumieniu według jednego bajtu. (Odziedziczone po Stream)

Metody rozszerzania

CopyToAsync(Stream, PipeWriter, CancellationToken)	Asynchronicznie odczytuje bajty z Stream i zapisuje je w określonym PipeWriterprzy użyciu tokenu anulowania.
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguruje, w jaki sposób będą wykonywane oczekiwania na zadania zwrócone z asynchronicznego jednorazowego użytku.

Zobacz też

• zmiany uwierzytelniania NTLM dla żądania HTTPWebRequest w wersji 3.5 SP1