NegotiateStream Klasse

Definition

Namespace:

System.Net.Security

Assembly:

System.Net.Security.dll

Quelle:

NegotiateStream.cs

Stellt einen Datenstrom bereit, der das Negotiate-Sicherheitsprotokoll verwendet, um den Client und optional den Server in der Clientserverkommunikation zu authentifizieren.

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

Vererbung

Object

MarshalByRefObject

Stream

AuthenticatedStream

NegotiateStream

Beispiele

Im folgenden Beispiel wird die Clientseite einer Clientserververbindung veranschaulicht, die die NegotiateStreamverwendet. Der Client authentifiziert und sendet asynchron eine Nachricht an den Server.

#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

Im folgenden Codebeispiel wird die Serverseite einer Clientserververbindung veranschaulicht, die die NegotiateStream verwendet, um den Client zu authentifizieren und eine vom Client gesendete Nachricht zu lesen.

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

Hinweise

Verwenden Sie die NegotiateStream-Klasse für die Authentifizierung und helfen Sie bei der Sicherung von Informationen, die zwischen einem Client und einem Server übertragen werden. Mit NegotiateStreamkönnen Sie die folgenden Aktionen ausführen.

• Senden Sie die Anmeldeinformationen des Clients an den Server für Identitätswechsel oder Delegierung.

• Anfordern der Serverauthentifizierung.

• Verschlüsseln und/oder signieren Sie Daten, bevor Sie sie übertragen.

Die Authentifizierung muss vor der Übermittlung von Informationen durchgeführt werden. Clients fordern die Authentifizierung mithilfe der synchronen AuthenticateAsClient Methoden an, die bis zum Abschluss der Authentifizierung blockiert werden, oder die asynchronen BeginAuthenticateAsClient Methoden, die beim Warten auf den Abschluss der Authentifizierung nicht blockiert werden. Server fordern die Authentifizierung mithilfe der synchronen AuthenticateAsServer oder asynchronen BeginAuthenticateAsServer Methoden an. Der Client und optional der Server werden mithilfe des Negotiate-Sicherheitsprotokolls authentifiziert. Das Kerberos-Protokoll wird für die Authentifizierung verwendet, wenn client- und serverseitig unterstützt werden. andernfalls wird NTLM verwendet. Die NegotiateStream Klasse führt die Authentifizierung mithilfe der SSPI (Security Support Provider Interface) durch.

Wenn die Authentifizierung erfolgreich ist, müssen Sie die IsEncrypted und IsSigned Eigenschaften überprüfen, um zu ermitteln, welche Sicherheitsdienste vom NegotiateStream verwendet werden, um Ihre Daten während der Übertragung zu sichern. Überprüfen Sie die eigenschaft IsMutuallyAuthenticated, um festzustellen, ob die gegenseitige Authentifizierung aufgetreten ist. Mithilfe der RemoteIdentity-Eigenschaft können Sie Informationen zum Remoteclient oder Server abrufen.

Wenn die Authentifizierung fehlschlägt, erhalten Sie eine AuthenticationException oder eine InvalidCredentialException. In diesem Fall können Sie die Authentifizierung mit anderen Anmeldeinformationen wiederholen.

Sie senden Daten mithilfe der synchronen Write oder asynchronen BeginWrite oder WriteAsync Methoden. Sie empfangen Daten mithilfe der synchronen Read oder asynchronen ReadAsync oder BeginRead Methoden. Wenn Sicherheitsdienste wie Verschlüsselung oder Signatur aktiviert sind, werden diese automatisch von der NegotiateStreamauf Ihre Daten angewendet.

Die NegotiateStream überträgt Daten mithilfe eines Datenstroms, den Sie beim Erstellen der NegotiateStreamangeben. Wenn Sie diesen zugrunde liegenden Datenstrom bereitstellen, können Sie angeben, ob das schließende NegotiateStream auch den zugrunde liegenden Datenstrom schließt.

Konstruktoren

NegotiateStream(Stream)	Initialisiert eine neue Instanz der NegotiateStream Klasse mithilfe der angegebenen Stream.
NegotiateStream(Stream, Boolean)	Initialisiert eine neue Instanz der NegotiateStream Klasse mithilfe des angegebenen Stream- und Datenstromschließverhaltens.

Eigenschaften

CanRead	Ruft einen Boolean Wert ab, der angibt, ob der zugrunde liegende Datenstrom lesbar ist.
CanSeek	Ruft einen Boolean Wert ab, der angibt, ob der zugrunde liegende Datenstrom suchbar ist.
CanTimeout	Ruft einen Boolean Wert ab, der angibt, ob der zugrunde liegende Datenstrom Timeouts unterstützt.
CanWrite	Ruft einen Boolean Wert ab, der angibt, ob der zugrunde liegende Datenstrom schreibbar ist.
ImpersonationLevel	Ruft einen Wert ab, der angibt, wie der Server die Anmeldeinformationen des Clients verwenden kann.
InnerStream	Ruft den datenstrom ab, der von diesem AuthenticatedStream zum Senden und Empfangen von Daten verwendet wird. (Geerbt von AuthenticatedStream)
IsAuthenticated	Ruft einen Boolean Wert ab, der angibt, ob die Authentifizierung erfolgreich war.
IsEncrypted	Ruft einen Boolean Wert ab, der angibt, ob diese NegotiateStream Datenverschlüsselung verwendet.
IsMutuallyAuthenticated	Ruft einen Boolean Wert ab, der angibt, ob sowohl der Server als auch der Client authentifiziert wurden.
IsServer	Ruft einen Boolean Wert ab, der angibt, ob die lokale Seite der verbindung, die von diesem NegotiateStream verwendet wurde, als Server authentifiziert wurde.
IsSigned	Ruft einen Boolean Wert ab, der angibt, ob die mit diesem Datenstrom gesendeten Daten signiert sind.
LeaveInnerStreamOpen	Ruft ab, ob der von diesem AuthenticatedStream zum Senden und Empfangen von Daten verwendete Daten offen gelassen wurde. (Geerbt von AuthenticatedStream)
Length	Ruft die Länge des zugrunde liegenden Datenstroms ab.
Position	Ruft die aktuelle Position im zugrunde liegenden Datenstrom ab oder legt sie fest.
ReadTimeout	Ruft ab oder legt fest, wie lange ein Lesevorgang auf Daten wartet.
RemoteIdentity	Ruft Informationen zur Identität der Remotepartei ab, die diesen authentifizierten Datenstrom freigibt.
WriteTimeout	Ruft ab oder legt fest, wie lange ein Schreibvorgang auf Daten wartet.

Methoden

AuthenticateAsClient()	Wird von Clients aufgerufen, um den Client und optional den Server in einer Clientserververbindung zu authentifizieren.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	Wird von Clients aufgerufen, um den Client und optional den Server in einer Clientserververbindung zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Clientanmeldeinformationen und die Kanalbindung.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Wird von Clients aufgerufen, um den Client und optional den Server in einer Clientserververbindung zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Anmeldeinformationen, Authentifizierungsoptionen und Kanalbindung.
AuthenticateAsClient(NetworkCredential, String)	Wird von Clients aufgerufen, um den Client und optional den Server in einer Clientserververbindung zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Clientanmeldeinformationen.
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Wird von Clients aufgerufen, um den Client und optional den Server in einer Clientserververbindung zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Anmeldeinformationen und Authentifizierungsoptionen.
AuthenticateAsClientAsync()	Wird von Clients aufgerufen, um den Client und optional den Server in einer Clientserververbindung als asynchronen Vorgang zu authentifizieren.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Wird von Clients aufgerufen, um den Client und optional den Server in einer Clientserververbindung als asynchronen Vorgang zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Clientanmeldeinformationen und die Kanalbindung.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Wird von Clients aufgerufen, um den Client und optional den Server in einer Clientserververbindung als asynchronen Vorgang zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Anmeldeinformationen, Authentifizierungsoptionen und Kanalbindung.
AuthenticateAsClientAsync(NetworkCredential, String)	Wird von Clients aufgerufen, um den Client und optional den Server in einer Clientserververbindung als asynchronen Vorgang zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Clientanmeldeinformationen.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Wird von Clients aufgerufen, um den Client und optional den Server in einer Clientserververbindung als asynchronen Vorgang zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Anmeldeinformationen und Authentifizierungsoptionen.
AuthenticateAsServer()	Wird von Servern aufgerufen, um den Client und optional den Server in einer Clientserververbindung zu authentifizieren.
AuthenticateAsServer(ExtendedProtectionPolicy)	Wird von Servern aufgerufen, um den Client und optional den Server in einer Clientserververbindung zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebene erweiterte Schutzrichtlinie.
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Wird von Servern aufgerufen, um den Client und optional den Server in einer Clientserververbindung zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Serveranmeldeinformationen, Authentifizierungsoptionen und erweiterte Schutzrichtlinie.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Wird von Servern aufgerufen, um den Client und optional den Server in einer Clientserververbindung zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Serveranmeldeinformationen und Authentifizierungsoptionen.
AuthenticateAsServerAsync()	Wird von Servern aufgerufen, um den Client und optional den Server in einer Clientserververbindung als asynchronen Vorgang zu authentifizieren.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	Wird von Servern aufgerufen, um den Client und optional den Server in einer Clientserververbindung als asynchronen Vorgang zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebene erweiterte Schutzrichtlinie.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Wird von Servern aufgerufen, um den Client und optional den Server in einer Clientserververbindung als asynchronen Vorgang zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Serveranmeldeinformationen, Authentifizierungsoptionen und erweiterte Schutzrichtlinie.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Wird von Servern aufgerufen, um den Client und optional den Server in einer Clientserververbindung als asynchronen Vorgang zu authentifizieren. Der Authentifizierungsprozess verwendet die angegebenen Serveranmeldeinformationen und Authentifizierungsoptionen.
BeginAuthenticateAsClient(AsyncCallback, Object)	Wird von Clients aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Clients und optional den Server in einer Clientserververbindung zu starten. Diese Methode blockiert nicht.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Wird von Clients aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Clients und optional den Server in einer Clientserververbindung zu starten. Der Authentifizierungsprozess verwendet die angegebenen Anmeldeinformationen und die Kanalbindung. Diese Methode blockiert nicht.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Wird von Clients aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Clients und optional den Server in einer Clientserververbindung zu starten. Der Authentifizierungsprozess verwendet die angegebenen Anmeldeinformationen, Authentifizierungsoptionen und Kanalbindung. Diese Methode blockiert nicht.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Wird von Clients aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Clients und optional den Server in einer Clientserververbindung zu starten. Der Authentifizierungsprozess verwendet die angegebenen Anmeldeinformationen. Diese Methode blockiert nicht.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Wird von Clients aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Clients und optional den Server in einer Clientserververbindung zu starten. Der Authentifizierungsprozess verwendet die angegebenen Anmeldeinformationen und Authentifizierungsoptionen. Diese Methode blockiert nicht.
BeginAuthenticateAsServer(AsyncCallback, Object)	Wird von Servern aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Clients und optional den Server in einer Clientserververbindung zu starten. Diese Methode blockiert nicht.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)	Wird von Servern aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Clients und optional den Server in einer Clientserververbindung zu starten. Der Authentifizierungsprozess verwendet die angegebene erweiterte Schutzrichtlinie. Diese Methode blockiert nicht.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Wird von Servern aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Clients und optional den Server in einer Clientserververbindung zu starten. Der Authentifizierungsprozess verwendet die angegebenen Serveranmeldeinformationen, Authentifizierungsoptionen und erweiterte Schutzrichtlinie. Diese Methode blockiert nicht.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Wird von Servern aufgerufen, um einen asynchronen Vorgang zur Authentifizierung des Clients und optional den Server in einer Clientserververbindung zu starten. Der Authentifizierungsprozess verwendet die angegebenen Serveranmeldeinformationen und Authentifizierungsoptionen. Diese Methode blockiert nicht.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Startet einen asynchronen Lesevorgang, der Daten aus dem Datenstrom liest und im angegebenen Array speichert.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Startet einen asynchronen Schreibvorgang, der Bytes aus dem angegebenen Puffer in den Datenstrom schreibt.
Close()	Schließt den aktuellen Datenstrom und gibt alle Ressourcen (z. B. Sockets und Dateihandles) frei, die dem aktuellen Datenstrom zugeordnet sind. Anstatt diese Methode aufzurufen, stellen Sie sicher, dass der Datenstrom ordnungsgemäß verworfen ist. (Geerbt von Stream)
CopyTo(Stream)	Liest die Bytes aus dem aktuellen Datenstrom und schreibt sie in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyTo(Stream, Int32)	Liest die Bytes aus dem aktuellen Datenstrom und schreibt sie mithilfe einer angegebenen Puffergröße in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream)	Liest die Bytes asynchron aus dem aktuellen Datenstrom und schreibt sie in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, CancellationToken)	Liest die Bytes asynchron aus dem aktuellen Datenstrom und schreibt sie mithilfe eines angegebenen Abbruchtokens in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, Int32)	Liest die Bytes asynchron aus dem aktuellen Datenstrom und schreibt sie mithilfe einer angegebenen Puffergröße in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Liest asynchron die Bytes aus dem aktuellen Datenstrom und schreibt sie in einen anderen Datenstrom, wobei eine angegebene Puffergröße und ein Abbruchtoken verwendet wird. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CreateObjRef(Type)	Erstellt ein Objekt, das alle relevanten Informationen enthält, die zum Generieren eines Proxys erforderlich sind, der für die Kommunikation mit einem Remoteobjekt verwendet wird. (Geerbt von MarshalByRefObject)
CreateWaitHandle()	Veraltet. Weist ein WaitHandle-Objekt zu. (Geerbt von Stream)
Dispose()	Gibt alle vom Streamverwendeten Ressourcen frei. (Geerbt von Stream)
Dispose(Boolean)	Gibt die nicht verwalteten Ressourcen frei, die vom NegotiateStream verwendet werden, und gibt optional die verwalteten Ressourcen frei.
DisposeAsync()	Gibt asynchron die nicht verwalteten und verwalteten Ressourcen frei, die vom NegotiateStreamverwendet werden.
EndAuthenticateAsClient(IAsyncResult)	Beendet einen ausstehenden asynchronen Clientauthentifizierungsvorgang, der mit einem Aufruf von BeginAuthenticateAsClientgestartet wurde.
EndAuthenticateAsServer(IAsyncResult)	Beendet einen ausstehenden asynchronen Clientauthentifizierungsvorgang, der mit einem Aufruf von BeginAuthenticateAsServergestartet wurde.
EndRead(IAsyncResult)	Beendet einen asynchronen Lesevorgang, der mit einem Aufruf von BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)gestartet wurde.
EndWrite(IAsyncResult)	Beendet einen asynchronen Schreibvorgang, der mit einem Aufruf von BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)gestartet wurde.
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
Flush()	Bewirkt, dass alle gepufferten Daten auf das zugrunde liegende Gerät geschrieben werden.
FlushAsync()	Löscht asynchron alle Puffer für diesen Datenstrom und bewirkt, dass alle gepufferten Daten auf das zugrunde liegende Gerät geschrieben werden. (Geerbt von Stream)
FlushAsync(CancellationToken)	Schreibt asynchron alle gepufferten Daten auf das zugrunde liegende Gerät.
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinie für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt ab, um die Lebensdauerrichtlinie für diese Instanz zu steuern. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
ObjectInvariant()	Veraltet. Bietet Unterstützung für eine Contract. (Geerbt von Stream)
Read(Byte[], Int32, Int32)	Liest Daten aus diesem Datenstrom und speichert sie im angegebenen Array.
Read(Span<Byte>)	Wenn sie in einer abgeleiteten Klasse überschrieben werden, liest sie eine Bytesequenz aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes. (Geerbt von Stream)
ReadAsync(Byte[], Int32, Int32)	Liest asynchron eine Abfolge von Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes. (Geerbt von Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Liest Daten asynchron aus diesem Datenstrom und speichert sie im angegebenen Array.
ReadAsync(Memory<Byte>, CancellationToken)	Liest Daten asynchron aus dem NegotiateStream und speichert sie als asynchronen Vorgang in einem Bytespeicherbereich.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Liest mindestens eine Minimale Anzahl von Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes. (Geerbt von Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Liest asynchron mindestens eine Mindestanzahl von Bytes aus dem aktuellen Datenstrom, wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes und überwacht Abbruchanforderungen. (Geerbt von Stream)
ReadByte()	Liest ein Byte aus dem Datenstrom und wechselt die Position innerhalb des Datenstroms um ein Byte oder gibt -1 zurück, wenn am Ende des Datenstroms. (Geerbt von Stream)
ReadExactly(Byte[], Int32, Int32)	Liest count Anzahl von Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms. (Geerbt von Stream)
ReadExactly(Span<Byte>)	Liest Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms, bis die buffer gefüllt ist. (Geerbt von Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Liest asynchron count Anzahl von Bytes aus dem aktuellen Datenstrom, wechselt die Position innerhalb des Datenstroms und überwacht Abbruchanforderungen. (Geerbt von Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Liest asynchron Bytes aus dem aktuellen Datenstrom, wechselt die Position innerhalb des Datenstroms, bis die buffer gefüllt ist, und überwacht Abbruchanforderungen. (Geerbt von Stream)
Seek(Int64, SeekOrigin)	Löst NotSupportedExceptionaus.
SetLength(Int64)	Legt die Länge des zugrunde liegenden Datenstroms fest.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
Write(Byte[], Int32, Int32)	Schreiben Sie die angegebene Anzahl von Bytes mithilfe des angegebenen Puffers und Offsets in den zugrunde liegenden Datenstrom.
Write(ReadOnlySpan<Byte>)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird eine Bytesequenz in den aktuellen Datenstrom geschrieben und die aktuelle Position innerhalb dieses Datenstroms um die Anzahl der geschriebenen Bytes vorangestellt. (Geerbt von Stream)
WriteAsync(Byte[], Int32, Int32)	Schreibt asynchron eine Bytesequenz in den aktuellen Datenstrom und wechselt die aktuelle Position innerhalb dieses Datenstroms um die Anzahl der geschriebenen Bytes. (Geerbt von Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Schreiben Sie asynchron die angegebene Anzahl von Bytes in den zugrunde liegenden Datenstrom.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Schreiben Sie asynchron die angegebene Anzahl von Bytes in den zugrunde liegenden Datenstrom.
WriteByte(Byte)	Schreibt ein Byte in die aktuelle Position im Datenstrom und wechselt die Position innerhalb des Datenstroms um ein Byte. (Geerbt von Stream)

Erweiterungsmethoden

CopyToAsync(Stream, PipeWriter, CancellationToken)	Liest die Bytes asynchron aus dem Stream und schreibt sie mithilfe eines Abbruchtokens in das angegebene PipeWriter.
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguriert, wie auf die von einem asynchronen Einweg zurückgegebenen Aufgaben gewartet wird.

Weitere Informationen

• Änderungen an der NTLM-Authentifizierung für HTTPWebRequest in Version 3.5 SP1