NegotiateStream Kelas

Definisi

Ruang nama:

System.Net.Security

Rakitan:

System.Net.Security.dll

Sumber:

NegotiateStream.cs

Menyediakan aliran yang menggunakan protokol Negosiasi keamanan untuk mengautentikasi klien, dan secara opsional server, dalam komunikasi server klien.

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

Warisan

Object

MarshalByRefObject

Stream

AuthenticatedStream

NegotiateStream

Contoh

Contoh berikut menunjukkan sisi klien koneksi server klien yang menggunakan NegotiateStream. Klien mengautentikasi dan mengirim pesan ke server secara asinkron.

#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

Contoh kode berikut menunjukkan sisi server koneksi server klien yang menggunakan NegotiateStream untuk mengautentikasi klien dan membaca pesan yang dikirim oleh klien.

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

Keterangan

NegotiateStream Gunakan kelas untuk autentikasi dan untuk membantu mengamankan informasi yang dikirimkan antara klien dan server. Dengan menggunakan NegotiateStream, Anda dapat melakukan hal berikut.

• Kirim kredensial klien ke server untuk Peniruan Identitas atau Delegasi.

• Meminta autentikasi server.

• Mengenkripsi dan/atau menandatangani data sebelum mengirimkannya.

Autentikasi harus dilakukan sebelum mengirimkan informasi. Klien meminta autentikasi menggunakan metode sinkron AuthenticateAsClient , yang memblokir hingga autentikasi selesai, atau metode asinkron BeginAuthenticateAsClient , yang tidak memblokir saat menunggu autentikasi selesai. Server meminta autentikasi menggunakan metode sinkron AuthenticateAsServer atau asinkron BeginAuthenticateAsServer . Klien, dan secara opsional server, diautentikasi menggunakan protokol keamanan Negosiasi. Protokol Kerberos digunakan untuk autentikasi jika klien dan server mendukungnya; jika tidak, NTLM digunakan. Kelas NegotiateStream melakukan autentikasi menggunakan Antarmuka Penyedia Dukungan Keamanan (SSPI).

Ketika autentikasi berhasil, Anda harus memeriksa IsEncrypted properti dan IsSigned untuk menentukan layanan keamanan apa yang akan digunakan oleh NegotiateStream untuk membantu mengamankan data Anda selama transmisi. IsMutuallyAuthenticated Periksa properti untuk menentukan apakah terjadi autentikasi timbal balik. Anda bisa mendapatkan informasi tentang klien atau server jarak jauh menggunakan RemoteIdentity properti .

Jika autentikasi gagal, Anda akan menerima AuthenticationException atau InvalidCredentialException. Dalam hal ini, Anda dapat mencoba kembali autentikasi dengan kredensial yang berbeda.

Anda mengirim data menggunakan metode atau asinkron atau sinkron WriteBeginWriteWriteAsync . Anda menerima data menggunakan metode atau asinkron atau sinkron ReadReadAsyncBeginRead . Jika layanan keamanan seperti enkripsi atau penandatanganan diaktifkan, ini secara otomatis diterapkan ke NegotiateStreamdata Anda oleh .

mengirimkan NegotiateStream data menggunakan aliran yang Anda berikan saat membuat NegotiateStream. Saat Anda menyediakan aliran yang mendasar NegotiateStream ini, Anda memiliki opsi untuk menentukan apakah menutup juga menutup aliran yang mendasar.

Konstruktor

NegotiateStream(Stream)	Menginisialisasi instans NegotiateStream baru kelas menggunakan Stream.
NegotiateStream(Stream, Boolean)	Menginisialisasi instans NegotiateStream baru kelas menggunakan perilaku penutupan yang ditentukan Stream dan streaming.

Properti

CanRead	Boolean Mendapatkan nilai yang menunjukkan apakah aliran yang mendasar dapat dibaca.
CanSeek	Boolean Mendapatkan nilai yang menunjukkan apakah aliran yang mendasar dapat dicari.
CanTimeout	Boolean Mendapatkan nilai yang menunjukkan apakah aliran yang mendasar mendukung waktu habis.
CanWrite	Boolean Mendapatkan nilai yang menunjukkan apakah aliran yang mendasar dapat ditulis.
ImpersonationLevel	Mendapatkan nilai yang menunjukkan bagaimana server dapat menggunakan kredensial klien.
InnerStream	Mendapatkan aliran yang digunakan oleh ini AuthenticatedStream untuk mengirim dan menerima data. (Diperoleh dari AuthenticatedStream)
IsAuthenticated	Boolean Mendapatkan nilai yang menunjukkan apakah autentikasi berhasil.
IsEncrypted	Boolean Mendapatkan nilai yang menunjukkan apakah ini NegotiateStream menggunakan enkripsi data.
IsMutuallyAuthenticated	Boolean Mendapatkan nilai yang menunjukkan apakah server dan klien telah diautentikasi.
IsServer	Boolean Mendapatkan nilai yang menunjukkan apakah sisi lokal koneksi yang digunakan oleh ini NegotiateStream diautentikasi sebagai server.
IsSigned	Boolean Mendapatkan nilai yang menunjukkan apakah data yang dikirim menggunakan aliran ini ditandatangani.
LeaveInnerStreamOpen	Mendapatkan apakah aliran yang digunakan oleh ini AuthenticatedStream untuk mengirim dan menerima data telah dibiarkan terbuka. (Diperoleh dari AuthenticatedStream)
Length	Mendapatkan panjang aliran yang mendasar.
Position	Mendapatkan atau mengatur posisi saat ini di aliran yang mendasar.
ReadTimeout	Mendapatkan atau mengatur jumlah waktu operasi baca memblokir menunggu data.
RemoteIdentity	Mendapatkan informasi tentang identitas pihak jarak jauh yang berbagi aliran terautentikasi ini.
WriteTimeout	Mendapatkan atau mengatur jumlah waktu operasi tulis memblokir menunggu data.

Metode

AuthenticateAsClient()	Dipanggil oleh klien untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	Dipanggil oleh klien untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial klien yang ditentukan dan pengikatan saluran.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Dipanggil oleh klien untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial, opsi autentikasi, dan pengikatan saluran yang ditentukan.
AuthenticateAsClient(NetworkCredential, String)	Dipanggil oleh klien untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial klien yang ditentukan.
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Dipanggil oleh klien untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial dan opsi autentikasi yang ditentukan.
AuthenticateAsClientAsync()	Dipanggil oleh klien untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien sebagai operasi asinkron.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Dipanggil oleh klien untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien sebagai operasi asinkron. Proses autentikasi menggunakan kredensial klien yang ditentukan dan pengikatan saluran.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Dipanggil oleh klien untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien sebagai operasi asinkron. Proses autentikasi menggunakan kredensial, opsi autentikasi, dan pengikatan saluran yang ditentukan.
AuthenticateAsClientAsync(NetworkCredential, String)	Dipanggil oleh klien untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien sebagai operasi asinkron. Proses autentikasi menggunakan kredensial klien yang ditentukan.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Dipanggil oleh klien untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien sebagai operasi asinkron. Proses autentikasi menggunakan kredensial dan opsi autentikasi yang ditentukan.
AuthenticateAsServer()	Dipanggil oleh server untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien.
AuthenticateAsServer(ExtendedProtectionPolicy)	Dipanggil oleh server untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kebijakan perlindungan yang diperluas yang ditentukan.
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Dipanggil oleh server untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial server yang ditentukan, opsi autentikasi, dan kebijakan perlindungan yang diperluas.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Dipanggil oleh server untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial server dan opsi autentikasi yang ditentukan.
AuthenticateAsServerAsync()	Dipanggil oleh server untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien sebagai operasi asinkron.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	Dipanggil oleh server untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien sebagai operasi asinkron. Proses autentikasi menggunakan kebijakan perlindungan yang diperluas yang ditentukan.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Dipanggil oleh server untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien sebagai operasi asinkron. Proses autentikasi menggunakan kredensial server yang ditentukan, opsi autentikasi, dan kebijakan perlindungan yang diperluas.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Dipanggil oleh server untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien sebagai operasi asinkron. Proses autentikasi menggunakan kredensial server dan opsi autentikasi yang ditentukan.
BeginAuthenticateAsClient(AsyncCallback, Object)	Dipanggil oleh klien untuk memulai operasi asinkron untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Metode ini tidak memblokir.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Dipanggil oleh klien untuk memulai operasi asinkron untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial dan pengikatan saluran yang ditentukan. Metode ini tidak memblokir.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Dipanggil oleh klien untuk memulai operasi asinkron untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial, opsi autentikasi, dan pengikatan saluran yang ditentukan. Metode ini tidak memblokir.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Dipanggil oleh klien untuk memulai operasi asinkron untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial yang ditentukan. Metode ini tidak memblokir.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Dipanggil oleh klien untuk memulai operasi asinkron untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial dan opsi autentikasi yang ditentukan. Metode ini tidak memblokir.
BeginAuthenticateAsServer(AsyncCallback, Object)	Dipanggil oleh server untuk memulai operasi asinkron untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Metode ini tidak memblokir.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)	Dipanggil oleh server untuk memulai operasi asinkron untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kebijakan perlindungan yang diperluas yang ditentukan. Metode ini tidak memblokir.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Dipanggil oleh server untuk memulai operasi asinkron untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial server yang ditentukan, opsi autentikasi, dan kebijakan perlindungan yang diperluas. Metode ini tidak memblokir.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Dipanggil oleh server untuk memulai operasi asinkron untuk mengautentikasi klien, dan secara opsional server, dalam koneksi server klien. Proses autentikasi menggunakan kredensial server dan opsi autentikasi yang ditentukan. Metode ini tidak memblokir.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Memulai operasi baca asinkron yang membaca data dari aliran dan menyimpannya dalam array yang ditentukan.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Memulai operasi penulisan asinkron yang menulis Bytes dari buffer yang ditentukan ke aliran.
Close()	Menutup aliran saat ini dan merilis sumber daya apa pun (seperti soket dan handel file) yang terkait dengan aliran saat ini. Alih-alih memanggil metode ini, pastikan aliran dibuang dengan benar. (Diperoleh dari Stream)
CopyTo(Stream)	Membaca byte dari aliran saat ini dan menulisnya ke aliran lain. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin. (Diperoleh dari Stream)
CopyTo(Stream, Int32)	Membaca byte dari aliran saat ini dan menulisnya ke aliran lain, menggunakan ukuran buffer tertentu. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin. (Diperoleh dari Stream)
CopyToAsync(Stream)	Secara asinkron membaca byte dari aliran saat ini dan menulisnya ke aliran lain. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin. (Diperoleh dari Stream)
CopyToAsync(Stream, CancellationToken)	Secara asinkron membaca byte dari aliran saat ini dan menulisnya ke aliran lain, menggunakan token pembatalan yang ditentukan. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin. (Diperoleh dari Stream)
CopyToAsync(Stream, Int32)	Secara asinkron membaca byte dari aliran saat ini dan menulisnya ke aliran lain, menggunakan ukuran buffer tertentu. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin. (Diperoleh dari Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Secara asinkron membaca byte dari aliran saat ini dan menulisnya ke aliran lain, menggunakan ukuran buffer dan token pembatalan yang ditentukan. Kedua posisi aliran dimajukan dengan jumlah byte yang disalin. (Diperoleh dari Stream)
CreateObjRef(Type)	Membuat objek yang berisi semua informasi relevan yang diperlukan untuk menghasilkan proksi yang digunakan untuk berkomunikasi dengan objek jarak jauh. (Diperoleh dari MarshalByRefObject)
CreateWaitHandle()	Kedaluwarsa. Mengalokasikan WaitHandle objek. (Diperoleh dari Stream)
Dispose()	Merilis semua sumber daya yang Streamdigunakan oleh . (Diperoleh dari Stream)
Dispose(Boolean)	Merilis sumber daya tidak terkelola yang NegotiateStream digunakan oleh dan secara opsional merilis sumber daya terkelola.
DisposeAsync()	Secara asinkron merilis sumber daya yang tidak dikelola dan dikelola yang digunakan oleh NegotiateStream.
EndAuthenticateAsClient(IAsyncResult)	Mengakhiri operasi autentikasi klien asinkron yang tertunda yang dimulai dengan panggilan ke BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Mengakhiri operasi autentikasi klien asinkron yang tertunda yang dimulai dengan panggilan ke BeginAuthenticateAsServer.
EndRead(IAsyncResult)	Mengakhiri operasi baca asinkron yang dimulai dengan panggilan ke BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Mengakhiri operasi penulisan asinkron yang dimulai dengan panggilan ke BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Menentukan apakah objek yang ditentukan sama dengan objek saat ini. (Diperoleh dari Object)
Flush()	Menyebabkan data buffer ditulis ke perangkat yang mendasar.
FlushAsync()	Secara asinkron menghapus semua buffer untuk aliran ini dan menyebabkan data buffer ditulis ke perangkat yang mendasar. (Diperoleh dari Stream)
FlushAsync(CancellationToken)	Secara asinkron menulis data yang di-buffer ke perangkat yang mendasar.
GetHashCode()	Berfungsi sebagai fungsi hash default. (Diperoleh dari Object)
GetLifetimeService()	Kedaluwarsa. Mengambil objek layanan seumur hidup saat ini yang mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject)
GetType()	Mendapatkan instans Type saat ini. (Diperoleh dari Object)
InitializeLifetimeService()	Kedaluwarsa. Mendapatkan objek layanan seumur hidup untuk mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject)
MemberwiseClone()	Membuat salinan dangkal dari yang saat ini Object. (Diperoleh dari Object)
MemberwiseClone(Boolean)	Membuat salinan dangkal objek saat ini MarshalByRefObject . (Diperoleh dari MarshalByRefObject)
ObjectInvariant()	Kedaluwarsa. Menyediakan dukungan untuk Contract. (Diperoleh dari Stream)
Read(Byte[], Int32, Int32)	Membaca data dari aliran ini dan menyimpannya dalam array yang ditentukan.
Read(Span<Byte>)	Ketika ditimpa di kelas turunan, membaca urutan byte dari aliran saat ini dan memajukan posisi dalam aliran dengan jumlah byte yang dibaca. (Diperoleh dari Stream)
ReadAsync(Byte[], Int32, Int32)	Secara asinkron membaca urutan byte dari aliran saat ini dan memajukan posisi dalam aliran dengan jumlah byte yang dibaca. (Diperoleh dari Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Membaca data secara asinkron dari aliran ini dan menyimpannya dalam array yang ditentukan.
ReadAsync(Memory<Byte>, CancellationToken)	Membaca data secara asinkron dari NegotiateStream dan menyimpannya dalam rentang memori byte sebagai operasi asinkron.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Membaca setidaknya jumlah minimum byte dari aliran saat ini dan memajukan posisi dalam aliran dengan jumlah byte yang dibaca. (Diperoleh dari Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Secara asinkron membaca setidaknya jumlah minimum byte dari aliran saat ini, memajukan posisi dalam aliran dengan jumlah byte yang dibaca, dan memantau permintaan pembatalan. (Diperoleh dari Stream)
ReadByte()	Membaca byte dari aliran dan memajukan posisi dalam aliran satu byte, atau mengembalikan -1 jika di akhir aliran. (Diperoleh dari Stream)
ReadExactly(Byte[], Int32, Int32)	count Membaca jumlah byte dari aliran saat ini dan memajukan posisi dalam aliran. (Diperoleh dari Stream)
ReadExactly(Span<Byte>)	Membaca byte dari aliran saat ini dan memajukan posisi dalam aliran hingga buffer terisi. (Diperoleh dari Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Secara asinkron membaca count jumlah byte dari aliran saat ini, memajukan posisi dalam aliran, dan memantau permintaan pembatalan. (Diperoleh dari Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Secara asinkron membaca byte dari aliran saat ini, memajukan posisi dalam aliran hingga buffer terisi, dan memantau permintaan pembatalan. (Diperoleh dari Stream)
Seek(Int64, SeekOrigin)	NotSupportedExceptionMelempar .
SetLength(Int64)	Mengatur panjang aliran yang mendasar.
ToString()	Mengembalikan string yang mewakili objek saat ini. (Diperoleh dari Object)
Write(Byte[], Int32, Int32)	Tulis jumlah Bytes yang ditentukan ke aliran yang mendasar menggunakan buffer dan offset yang ditentukan.
Write(ReadOnlySpan<Byte>)	Ketika ditimpa di kelas turunan, menulis urutan byte ke aliran saat ini dan memajukan posisi saat ini dalam aliran ini dengan jumlah byte yang ditulis. (Diperoleh dari Stream)
WriteAsync(Byte[], Int32, Int32)	Secara asinkron menulis urutan byte ke aliran saat ini dan memajukan posisi saat ini dalam aliran ini dengan jumlah byte yang ditulis. (Diperoleh dari Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Tulis secara asinkron jumlah Bytes yang ditentukan ke aliran yang mendasar.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Tulis secara asinkron jumlah Bytes yang ditentukan ke aliran yang mendasar.
WriteByte(Byte)	Menulis byte ke posisi saat ini di aliran dan memajukan posisi dalam aliran satu byte. (Diperoleh dari Stream)

Metode Ekstensi

CopyToAsync(Stream, PipeWriter, CancellationToken)	Secara asinkron membaca byte dari Stream dan menulisnya ke yang ditentukan PipeWriter, menggunakan token pembatalan.
ConfigureAwait(IAsyncDisposable, Boolean)	Mengonfigurasi bagaimana menunggu tugas yang dikembalikan dari asinkron sekali pakai dilakukan.

Lihat juga

• Perubahan pada autentikasi NTLM untuk HTTPWebRequest di Versi 3.5 SP1