SslStream Osztály

Definíció

Névtér:

System.Net.Security

Szerelvény:

System.dll

Az ügyfél-kiszolgáló kommunikációhoz használt streamet biztosít, amely a Secure Socket Layer (SSL) biztonsági protokollt használja a kiszolgáló és opcionálisan az ügyfél hitelesítéséhez.

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

public class SslStream : System.Net.Security.AuthenticatedStream

type SslStream = class
    inherit AuthenticatedStream

Public Class SslStream
Inherits AuthenticatedStream

Öröklődés

Object

MarshalByRefObject

Stream

AuthenticatedStream

SslStream

Példák

Az alábbi példakód bemutatja, hogyan hozhat létre olyan objektumot TcpListener , amely az osztályt használja az SslStream ügyfelekkel való kommunikációhoz.

using System;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.IO;

namespace Examples.System.Net
{
    public sealed class SslTcpServer
    {
        static X509Certificate serverCertificate = null;
        // The certificate parameter specifies the name of the file
        // containing the machine certificate.
        public static void RunServer(string certificate)
        {
            serverCertificate = X509Certificate.CreateFromCertFile(certificate);
            // Create a TCP/IP (IPv4) socket and listen for incoming connections.
            TcpListener listener = new TcpListener(IPAddress.Any, 5000);
            listener.Start();
            while (true)
            {
                Console.WriteLine("Waiting for a client to connect...");
                // Application blocks while waiting for an incoming connection.
                // Type CNTL-C to terminate the server.
                TcpClient client = listener.AcceptTcpClient();
                ProcessClient(client);
            }
        }
        static void ProcessClient (TcpClient client)
        {
            // A client has connected. Create the
            // SslStream using the client's network stream.
            SslStream sslStream = new SslStream(
                client.GetStream(), false);
            // Authenticate the server but don't require the client to authenticate.
            try
            {
                sslStream.AuthenticateAsServer(serverCertificate, clientCertificateRequired: false, checkCertificateRevocation: true);

                // Display the properties and settings for the authenticated stream.
                DisplaySecurityLevel(sslStream);
                DisplaySecurityServices(sslStream);
                DisplayCertificateInformation(sslStream);
                DisplayStreamProperties(sslStream);

                // Set timeouts for the read and write to 5 seconds.
                sslStream.ReadTimeout = 5000;
                sslStream.WriteTimeout = 5000;
                // Read a message from the client.
                Console.WriteLine("Waiting for client message...");
                string messageData = ReadMessage(sslStream);
                Console.WriteLine("Received: {0}", messageData);

                // Write a message to the client.
                byte[] message = Encoding.UTF8.GetBytes("Hello from the server.<EOF>");
                Console.WriteLine("Sending hello message.");
                sslStream.Write(message);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine ("Authentication failed - closing the connection.");
                sslStream.Close();
                client.Close();
                return;
            }
            finally
            {
                // The client stream will be closed with the sslStream
                // because we specified this behavior when creating
                // the sslStream.
                sslStream.Close();
                client.Close();
            }
        }
        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the client.
            // The client signals the end of the message using the
            // "<EOF>" marker.
            byte [] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                // Read the client's test message.
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
                decoder.GetChars(buffer, 0, bytes, chars,0);
                messageData.Append (chars);
                // Check for EOF or an empty message.
                if (messageData.ToString().IndexOf("<EOF>") != -1)
                {
                    break;
                }
            } while (bytes !=0);

            return messageData.ToString();
        }
         static void DisplaySecurityLevel(SslStream stream)
         {
            Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength);
            Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength);
            Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength);
            Console.WriteLine("Protocol: {0}", stream.SslProtocol);
         }
         static void DisplaySecurityServices(SslStream stream)
         {
            Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer);
            Console.WriteLine("IsSigned: {0}", stream.IsSigned);
            Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted);
            Console.WriteLine("Is mutually authenticated: {0}", stream.IsMutuallyAuthenticated);
         }
         static void DisplayStreamProperties(SslStream stream)
         {
            Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite);
            Console.WriteLine("Can timeout: {0}", stream.CanTimeout);
         }
        static void DisplayCertificateInformation(SslStream stream)
        {
            Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus);

            X509Certificate localCertificate = stream.LocalCertificate;
            if (stream.LocalCertificate != null)
            {
                Console.WriteLine("Local cert was issued to {0} and is valid from {1} until {2}.",
                    localCertificate.Subject,
                    localCertificate.GetEffectiveDateString(),
                    localCertificate.GetExpirationDateString());
             } else
            {
                Console.WriteLine("Local certificate is null.");
            }
            // Display the properties of the client's certificate.
            X509Certificate remoteCertificate = stream.RemoteCertificate;
            if (stream.RemoteCertificate != null)
            {
            Console.WriteLine("Remote cert was issued to {0} and is valid from {1} until {2}.",
                remoteCertificate.Subject,
                remoteCertificate.GetEffectiveDateString(),
                remoteCertificate.GetExpirationDateString());
            } else
            {
                Console.WriteLine("Remote certificate is null.");
            }
        }
        private static void DisplayUsage()
        {
            Console.WriteLine("To start the server specify:");
            Console.WriteLine("serverSync certificateFile.cer");
            Environment.Exit(1);
        }
        public static int Main(string[] args)
        {
            string certificate = null;
            if (args == null ||args.Length < 1 )
            {
                DisplayUsage();
            }
            certificate = args[0];
            SslTcpServer.RunServer (certificate);
            return 0;
        }
    }
}

Imports System.Collections
Imports System.Net
Imports System.Net.Sockets
Imports System.Net.Security
Imports System.Security.Authentication
Imports System.Text
Imports System.Security.Cryptography.X509Certificates
Imports System.IO

Namespace Examples.System.Net
    Public NotInheritable Class SslTcpServer
        Shared serverCertificate As X509Certificate = Nothing

        ' The certificate parameter specifies the name of the file 
        ' containing the machine certificate.
        Public Shared Sub RunServer(certificate As String)
            serverCertificate = X509Certificate.CreateFromCertFile(certificate)
            ' Create a TCP/IP (IPv4) socket And listen for incoming connections.
            Dim listener = New TcpListener(IPAddress.Any, 5000)
            listener.Start()

            While True
                Console.WriteLine("Waiting for a client to connect...")
                ' Application blocks while waiting for an incoming connection.
                ' Type CNTL-C to terminate the server.
                Dim client As TcpClient = listener.AcceptTcpClient()
                ProcessClient(client)
            End While
        End Sub
        Private Shared Sub ProcessClient(client As TcpClient)
            ' A client has connected. Create the 
            ' SslStream using the client's network stream.
            Dim sslStream = New SslStream(client.GetStream(), False)

            Try

                sslStream.AuthenticateAsServer(serverCertificate, clientCertificateRequired:=False, checkCertificateRevocation:=True)
                ' Display the properties And settings for the authenticated stream.
                DisplaySecurityLevel(sslStream)
                DisplaySecurityServices(sslStream)
                DisplayCertificateInformation(sslStream)
                DisplayStreamProperties(sslStream)

                ' Set timeouts for the read and write to 5 seconds.
                sslStream.ReadTimeout = 5000
                sslStream.WriteTimeout = 5000

                ' Read a message from the client.   
                Console.WriteLine("Waiting for client message...")
                Dim messageData As String = ReadMessage(sslStream)
                Console.WriteLine("Received: {0}", messageData)

                ' Write a message to the client.
                Dim message As Byte() = Encoding.UTF8.GetBytes("Hello from the server.<EOF>")
                Console.WriteLine("Sending hello message.")
                sslStream.Write(message)
            Catch e As AuthenticationException
                Console.WriteLine("Exception: {0}", e.Message)

                If e.InnerException IsNot Nothing Then
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message)
                End If

                Console.WriteLine("Authentication failed - closing the connection.")
                sslStream.Close()
                client.Close()
                Return
            Finally
                ' The client stream will be closed with the sslStream
                ' because we specified this behavior when creating
                ' the sslStream.
                sslStream.Close()
                client.Close()
            End Try
        End Sub

        Private Shared Function ReadMessage(sslStream As SslStream) As String

            ' Read the  message sent by the client.
            ' The client signals the end of the message using the
            ' "<EOF>" marker.
            Dim buffer As Byte() = New Byte(2048) {}
            Dim messageData As StringBuilder = New StringBuilder()
            Dim bytes As Integer = -1

            Do
                ' Read the client's test message.
                bytes = sslStream.Read(buffer, 0, buffer.Length)

                ' Use decoder class to convert from bytes to UTF8
                ' in case a character spans two buffers.
                Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
                Dim chars As Char() = New Char(decoder.GetCharCount(buffer, 0, bytes) - 1) {}
                decoder.GetChars(buffer, 0, bytes, chars, 0)
                messageData.Append(chars)

                ' Check for EOF or an empty message.
                If messageData.ToString().IndexOf("<EOF>") <> -1 Then
                    Exit Do
                End If
            Loop While bytes <> 0

            Return messageData.ToString()
        End Function

        Private Shared Sub DisplaySecurityLevel(stream As SslStream)
            Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength)
            Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength)
            Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength)
            Console.WriteLine("Protocol: {0}", stream.SslProtocol)
        End Sub

        Private Shared Sub DisplaySecurityServices(stream As SslStream)
            Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer)
            Console.WriteLine("IsSigned: {0}", stream.IsSigned)
            Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted)
            Console.WriteLine("Is mutually authenticated: {0}", stream.IsMutuallyAuthenticated)
        End Sub

        Private Shared Sub DisplayStreamProperties(stream As SslStream)
            Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite)
            Console.WriteLine("Can timeout: {0}", stream.CanTimeout)
        End Sub

        Private Shared Sub DisplayCertificateInformation(stream As SslStream)
            Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus)
            Dim localCertificate As X509Certificate = stream.LocalCertificate

            If stream.LocalCertificate IsNot Nothing Then
                Console.WriteLine("Local cert was issued to {0} and is valid from {1} until {2}.", localCertificate.Subject, localCertificate.GetEffectiveDateString(), localCertificate.GetExpirationDateString())
            Else
                Console.WriteLine("Local certificate is null.")
            End If

            ' Display the properties of the client's certificate.
            Dim remoteCertificate As X509Certificate = stream.RemoteCertificate

            If stream.RemoteCertificate IsNot Nothing Then
                Console.WriteLine("Remote cert was issued to {0} and is valid from {1} until {2}.", remoteCertificate.Subject, remoteCertificate.GetEffectiveDateString(), remoteCertificate.GetExpirationDateString())
            Else
                Console.WriteLine("Remote certificate is null.")
            End If
        End Sub

        Private Shared Sub DisplayUsage()
            Console.WriteLine("To start the server specify:")
            Console.WriteLine("serverSync certificateFile.cer")
            Environment.[Exit](1)
        End Sub

        Public Shared Function Main(ByVal args As String()) As Integer
            Dim certificate As String

            If args Is Nothing OrElse args.Length < 1 Then
                DisplayUsage()
            End If

            certificate = args(0)
            RunServer(certificate)
            Return 0
        End Function
    End Class
End Namespace

Az alábbi példakód bemutatja, hogyan hozhat létre egy olyan objektumot TcpClient , amely az SslStream osztályt használja a kiszolgálóval való kommunikációhoz.

using System;
using System.Collections;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.IO;

namespace Examples.System.Net
{
    public class SslTcpClient
    {
        private static Hashtable certificateErrors = new Hashtable();

        // The following method is invoked by the RemoteCertificateValidationDelegate.
        public static bool ValidateServerCertificate(
              object sender,
              X509Certificate certificate,
              X509Chain chain,
              SslPolicyErrors sslPolicyErrors)
        {
           if (sslPolicyErrors == SslPolicyErrors.None)
                return true;

            Console.WriteLine("Certificate error: {0}", sslPolicyErrors);

            // Do not allow this client to communicate with unauthenticated servers.
            return false;
        }
        public static void RunClient(string machineName, string serverName)
        {
            // Create a TCP/IP client socket.
            // machineName is the host running the server application.
            TcpClient client = new TcpClient(machineName,5000);
            Console.WriteLine("Client connected.");
            // Create an SSL stream that will close the client's stream.
            SslStream sslStream = new SslStream(
                client.GetStream(),
                false,
                new RemoteCertificateValidationCallback (ValidateServerCertificate),
                null
                );
            // The server name must match the name on the server certificate.
            try
            {
                sslStream.AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine ("Authentication failed - closing the connection.");
                client.Close();
                return;
            }
            // Encode a test message into a byte array.
            // Signal the end of the message using the "<EOF>".
            byte[] messsage = Encoding.UTF8.GetBytes("Hello from the client.<EOF>");
            // Send hello message to the server.
            sslStream.Write(messsage);
            sslStream.Flush();
            // Read message from the server.
            string serverMessage = ReadMessage(sslStream);
            Console.WriteLine("Server says: {0}", serverMessage);
            // Close the client connection.
            client.Close();
            Console.WriteLine("Client closed.");
        }
        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the server.
            // The end of the message is signaled using the
            // "<EOF>" marker.
            byte [] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
                decoder.GetChars(buffer, 0, bytes, chars,0);
                messageData.Append (chars);
                // Check for EOF.
                if (messageData.ToString().IndexOf("<EOF>") != -1)
                {
                    break;
                }
            } while (bytes != 0);

            return messageData.ToString();
        }
        private static void DisplayUsage()
        {
            Console.WriteLine("To start the client specify:");
            Console.WriteLine("clientSync machineName [serverName]");
            Environment.Exit(1);
        }
        public static int Main(string[] args)
        {
            string serverCertificateName = null;
            string machineName = null;
            if (args == null ||args.Length <1 )
            {
                DisplayUsage();
            }
            // User can specify the machine name and server name.
            // Server name must match the name on the server's certificate.
            machineName = args[0];
            if (args.Length <2 )
            {
                serverCertificateName = machineName;
            }
            else
            {
                serverCertificateName = args[1];
            }
            SslTcpClient.RunClient (machineName, serverCertificateName);
            return 0;
        }
    }
}

Imports System.Collections
Imports System.Net
Imports System.Net.Security
Imports System.Net.Sockets
Imports System.Security.Authentication
Imports System.Text
Imports System.Security.Cryptography.X509Certificates
Imports System.IO

Namespace Examples.System.Net

    Public Class SslTcpClient
        
        ' The following method is invoked by the RemoteCertificateValidationDelegate.
        Public Shared Function ValidateServerCertificate(
            sender As Object, 
            certificate As X509Certificate, 
            chain As X509Chain, 
            sslPolicyErrors As SslPolicyErrors) As Boolean
            
            If sslPolicyErrors = SslPolicyErrors.None Then Return True

            Console.WriteLine("Certificate error: {0}", sslPolicyErrors)

            ' Do not allow this client to communicate with unauthenticated servers.
            Return False
        End Function
        Public Shared Sub RunClient(machineName As String, serverName As String)

            ' Create a TCP/IP client socket.
            ' machineName is the host running the server application.
            Dim client = New TcpClient(machineName, 5000)
            Console.WriteLine("Client connected.")

            ' Create an SSL stream that will close the client's stream.
            Dim sslStream = New SslStream(
                client.GetStream(), False, 
                New RemoteCertificateValidationCallback(AddressOf ValidateServerCertificate), Nothing)

            ' The server name must match the name on the server certificate.
            Try
                sslStream.AuthenticateAsClient(serverName)
            Catch e As AuthenticationException
                Console.WriteLine("Exception: {0}", e.Message)

                If e.InnerException IsNot Nothing Then
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message)
                End If

                Console.WriteLine("Authentication failed - closing the connection.")
                client.Close()
                Return
            End Try
            
            ' Encode a test message into a byte array.
            ' Signal the end of the message using the "<EOF>".
            Dim messsage As Byte() = Encoding.UTF8.GetBytes("Hello from the client.<EOF>")
            
            ' Send hello message to the server.
            sslStream.Write(messsage)
            sslStream.Flush()
            ' Read message from the server.
            Dim serverMessage = ReadMessage(sslStream)
            Console.WriteLine("Server says: {0}", serverMessage)

            ' Close the client connection
            client.Close()
            Console.WriteLine("Client closed.")
        End Sub
        
        Private Shared Function ReadMessage(sslStream As SslStream) As String

            ' Read the  message sent by the server.
            ' The end of the message is signaled using the "<EOF>" marker.
            Dim buffer = New Byte(2048) {}
            Dim messageData = New StringBuilder()
            Dim bytes As Integer

            Do
                bytes = sslStream.Read(buffer, 0, buffer.Length)

                ' Use Decoder class to convert from bytes to UTF8
                ' in case a character spans two buffers.        
                Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
                Dim chars = New Char(decoder.GetCharCount(buffer, 0, bytes) - 1) {}
                decoder.GetChars(buffer, 0, bytes, chars, 0)
                messageData.Append(chars)

                ' Check for EOF.
                If messageData.ToString().IndexOf("<EOF>") <> -1 Then Exit Do
                
            Loop While bytes <> 0

            Return messageData.ToString()

        End Function

        Private Shared Sub DisplayUsage()

            Console.WriteLine("To start the client specify:")
            Console.WriteLine("clientSync machineName [serverName]")
            Environment.[Exit](1)

        End Sub

        Public Shared Function Main(args As String()) As Integer

            Dim serverCertificateName As String
            Dim machineName As String

            If args Is Nothing OrElse args.Length < 1 Then
                DisplayUsage()
            End If

            ' User can specify the machine name and server name.
            ' Server name must match the name on the server's certificate. 
            machineName = args(0)

            If args.Length < 2 Then
                serverCertificateName = machineName
            Else
                serverCertificateName = args(1)
            End If

            SslTcpClient.RunClient(machineName, serverCertificateName)

            Return 0

        End Function

    End Class

End Namespace

Megjegyzések

Az SSL-protokollok segítenek a bizalmasság és az integritás ellenőrzésében az egy SslStream. A bizalmas információk ügyfél és kiszolgáló közötti kommunikációja során SSL-kapcsolatot kell használni, például az általuk SslStreambiztosítottat. SslStream Segítségével megakadályozhatja, hogy bárki elolvassa és illetéktelen módon módosítsa az információkat, miközben az átvitel alatt áll a hálózaton.

A SslStream példányok a rendszer által a rendszer létrehozásakor megadott adatfolyam használatával továbbítják az SslStreamadatokat. Az alapul szolgáló stream megadásakor megadhatja, hogy az SslStream alapul szolgáló stream bezárása is bezárja-e a streamet. Az osztályt általában az SslStream osztályokkal TcpClient együtt TcpListener használják. A GetStream módszer NetworkStream alkalmas az osztályhoz SslStream való használatra.

A kiszolgáló létrehozása SslStreamután és opcionálisan hitelesíteni kell az ügyfelet. A kiszolgálónak meg kell adnia egy X509-tanúsítványt, amely igazolja az identitását, és kérheti, hogy az ügyfél is ezt tegye. Hitelesítést kell végezni, mielőtt adatokat továbbítanának egy SslStream. Az ügyfelek a hitelesítést szinkron AuthenticateAsClient metódusokkal kezdeményezik, amelyek a hitelesítés befejezéséig blokkolják a hitelesítést, vagy az aszinkron BeginAuthenticateAsClient metódusokat, amelyek nem tiltják le a hitelesítés befejezésére való várakozást. A kiszolgálók szinkronizálási vagy aszinkron BeginAuthenticateAsServer módszerekkel kezdeményezik a AuthenticateAsServer hitelesítést. Az ügyfélnek és a kiszolgálónak is kezdeményeznie kell a hitelesítést.

A hitelesítést a biztonsági támogatási szolgáltató (SSPI) csatornaszolgáltatója kezeli. Az ügyfél egy meghatalmazott megadásával RemoteCertificateValidationCallback szabályozhatja a kiszolgáló tanúsítványának érvényesítését.SslStream A kiszolgáló egy meghatalmazott megadásával is szabályozhatja az érvényesítést RemoteCertificateValidationCallback . A meghatalmazott által hivatkozott metódus tartalmazza a távoli fél tanúsítványát, valamint a tanúsítvány érvényesítése során észlelt SSPI-hibákat. Vegye figyelembe, hogy ha a kiszolgáló delegáltat ad meg, a rendszer meghívja a meghatalmazott metódusát, függetlenül attól, hogy a kiszolgáló ügyfélhitelesítést kért-e. Ha a kiszolgáló nem kért ügyfél-hitelesítést, a kiszolgáló delegálási metódusa null tanúsítványt és egy üres tanúsítványhibákat tartalmazó tömböt kap.

Ha a kiszolgáló ügyfél-hitelesítést igényel, az ügyfélnek meg kell adnia egy vagy több tanúsítványt a hitelesítéshez. Ha az ügyfél több tanúsítvánnyal is rendelkezik, az ügyfél megadhat egy meghatalmazottat LocalCertificateSelectionCallback a kiszolgáló megfelelő tanúsítványának kiválasztásához. Az ügyfél tanúsítványainak az aktuális felhasználó "Saját" tanúsítványtárolójában kell lenniük. A (2-es SSL-verziójú) protokoll nem támogatja a tanúsítványokon keresztüli Ssl2 ügyfél-hitelesítést.

Ha a hitelesítés sikertelen, kap egy AuthenticationException, és a SslStream már nem használható. Zárja be ezt az objektumot, és távolítsa el az összes rá mutató hivatkozást, hogy a szemétgyűjtő összegyűjthesse.

Ha az SSL-kézfogásnak is nevezett hitelesítési folyamat sikeres, létrejön a kiszolgáló (és opcionálisan az ügyfél) identitása, és az ügyfél és a kiszolgáló használhatja az SslStream üzenetek cseréjére. Az információk elküldése vagy fogadása előtt az ügyfélnek és a kiszolgálónak ellenőriznie kell az általa SslStream biztosított biztonsági szolgáltatásokat és szinteket annak megállapításához, hogy a kiválasztott protokoll, algoritmusok és erősségek megfelelnek-e az integritásra és a bizalmasságra vonatkozó követelményeknek. Ha az aktuális beállítások nem elegendőek, a streamet le kell zárni. A használat és IsSigned a IsEncrypted tulajdonságok által SslStream biztosított biztonsági szolgáltatásokat ellenőrizheti. Az alábbi táblázat azokat az elemeket mutatja be, amelyek a hitelesítéshez, titkosításhoz és adataláíráshoz használt titkosítási beállításokat jelentik.

Elem	Tagok
A kiszolgáló és opcionálisan az ügyfél hitelesítéséhez használt biztonsági protokoll.	A SslProtocol tulajdonság és a kapcsolódó SslProtocols enumerálás.
A kulcscsere algoritmus.	A KeyExchangeAlgorithm tulajdonság és a kapcsolódó ExchangeAlgorithmType enumerálás.
Az üzenetintegritási algoritmus.	A HashAlgorithm tulajdonság és a kapcsolódó HashAlgorithmType enumerálás.
Az üzenet bizalmassági algoritmusa.	A CipherAlgorithm tulajdonság és a kapcsolódó CipherAlgorithmType enumerálás.
A kiválasztott algoritmusok erősségei.	A KeyExchangeStrength, HashStrengthés CipherStrength tulajdonságok.

A sikeres hitelesítés után szinkron vagy aszinkron BeginWrite módszerekkel küldhet adatokatWrite. Az adatokat szinkron Read vagy aszinkron BeginRead módszerekkel fogadhatja.

Ha azt a beállítást adta meg, hogy a SslStream mögöttes stream nyitva maradjon, a használat befejezésekor Ön a felelős a stream bezárásáért.

Note

Ha az SslStream objektumot létrehozó alkalmazás normál felhasználó hitelesítő adataival fut, az alkalmazás csak akkor férhet hozzá a helyi géptárolóban telepített tanúsítványokhoz, ha a felhasználó erre kifejezetten engedélyt kapott.

SslStream feltételezi, hogy egy időtúllépést és bármely más IOException időtúllépést a hívó végzetesnek fog kezelni a belső streamből való dobáskor. Ha időtúllépés után újrahasznál egy SslStream példányt, az szemetet ad vissza. Ezekben az esetekben az SslStream alkalmazásoknak kivételt kell tenniük, és kivételt kell Close tenniük.

A .NET Framework 4.6 tartalmaz egy biztonsági funkciót, amely blokkolja a nem biztonságos titkosítási és kivonatolási algoritmusokat a kapcsolatokhoz. A TLS/SSL-t api-kon keresztül használó alkalmazások, például a HttpClient, a HttpWebRequest, az FTPClient, az SmtpClient és az SslStream, valamint a .NET Framework 4.6 megcélzása alapértelmezés szerint biztonságosabb működést biztosít.

Előfordulhat, hogy a fejlesztők le szeretnék tiltani ezt a viselkedést a meglévő SSL3-szolgáltatásaikkal vagy tLS w/ RC4-szolgáltatásaikkal való együttműködés fenntartása érdekében. Ez a cikk bemutatja, hogyan módosíthatja a kódot úgy, hogy az új viselkedés le legyen tiltva.

A .NET Framework 4.7 új túlterheléseket ad az SslStreams hitelesítésére szolgáló metódusokhoz, amelyek nem adnak meg TLS-verziót, hanem a rendszer alapértelmezettként megadott TLS-verzióját használják a SCHANNEL. Ezeket a metódusokat az alkalmazásban úgy használhatja, hogy később módosíthatja az alapértelmezett beállításokat, mivel a TLS-verzió ajánlott eljárása idővel megváltozik, anélkül, hogy újra kellene építenie és újra üzembe kell helyeznie az alkalmazást.

Tekintse meg Transport Layer Security (TLS) ajánlott eljárásait a .NET Keretrendszerrel.

Konstruktorok

Name	Description
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)	Inicializálja az osztály új példányát a SslStream megadott Streamhasználatával.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)	Inicializálja az osztály új példányát a SslStream megadott Stream, streamlezárási viselkedés, tanúsítványérvényesítési delegált és tanúsítványkijelölési meghatalmazott használatával.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback)	Inicializálja az osztály új példányát a SslStream megadott Stream, streamlezárási viselkedés és tanúsítványérvényesítési meghatalmazott használatával.
SslStream(Stream, Boolean)	Inicializálja az osztály új példányát a SslStream megadott Stream és streamlezárási viselkedéssel.
SslStream(Stream)	Inicializálja az osztály új példányát a SslStream megadott Streamhasználatával.

Tulajdonságok

Name	Description
CanRead	Boolean Olyan értéket kap, amely jelzi, hogy az alapul szolgáló stream olvasható-e.
CanSeek	Boolean Olyan értéket kap, amely jelzi, hogy a mögöttes stream kereshető-e.
CanTimeout	Boolean Olyan értéket kap, amely jelzi, hogy a mögöttes stream támogatja-e az időtúllépéseket.
CanWrite	Boolean Olyan értéket kap, amely jelzi, hogy az alapul szolgáló stream írható-e.
CheckCertRevocationStatus	Boolean Olyan értéket kap, amely jelzi, hogy a tanúsítvány-visszavonási lista ellenőrzése a tanúsítványérvényesítési folyamat során történik-e.
CipherAlgorithm	Lekéri az ebben SslStreama szakaszban használt tömeges titkosítási algoritmust azonosító értéket.
CipherStrength	Olyan értéket kap, amely azonosítja az általa SslStreamhasznált titkosítási algoritmus erősségét.
HashAlgorithm	Lekéri az üzenethitelesítési kódok (MAC-k) létrehozásához használt algoritmust.
HashStrength	Lekéri a példány által használt kivonatoló algoritmus erősségét azonosító értéket.
InnerStream	Lekéri az adatküldéshez és -fogadáshoz használt AuthenticatedStream adatfolyamot. (Öröklődés forrása AuthenticatedStream)
IsAuthenticated	Boolean Olyan értéket kap, amely jelzi, hogy a hitelesítés sikeres volt-e.
IsEncrypted	Lekéri azt Boolean az értéket, amely jelzi, hogy ez SslStream használ-e adattitkosítást.
IsMutuallyAuthenticated	Boolean Olyan értéket kap, amely jelzi, hogy a kiszolgáló és az ügyfél hitelesítése megtörtént-e.
IsServer	Boolean Egy értéket kap, amely jelzi, hogy az általa használt kapcsolat helyi oldala hitelesítése kiszolgálóként történt-eSslStream.
IsSigned	Beolvas egy Boolean értéket, amely jelzi, hogy a stream használatával küldött adatok aláírtak-e.
KeyExchangeAlgorithm	Lekéri az ehhez a kulcscserélő algoritmushoz használt algoritmust SslStream.
KeyExchangeStrength	Olyan értéket kap, amely azonosítja a példány által használt kulcscsere-algoritmus erősségét.
LeaveInnerStreamOpen	Megállapítja, hogy az adatküldéshez AuthenticatedStream és -fogadáshoz használt stream nyitva maradt-e. (Öröklődés forrása AuthenticatedStream)
Length	Lekéri a mögöttes stream hosszát.
LocalCertificate	Lekéri a helyi végpont hitelesítéséhez használt tanúsítványt.
Position	Lekéri vagy beállítja az aktuális pozíciót a mögöttes streamben.
ReadTimeout	Ezredmásodpercben kifejezve lekéri vagy beállítja az adatra váró olvasási műveletblokkokat.
RemoteCertificate	Lekéri a távoli végpont hitelesítéséhez használt tanúsítványt.
SslProtocol	Lekéri a kapcsolat hitelesítéséhez használt biztonsági protokollt jelző értéket.
TransportContext	Lekéri a TransportContext kiterjesztett védelemmel történő hitelesítéshez használt eszközt.
WriteTimeout	Lekéri vagy beállítja, hogy egy írási művelet mennyi ideig blokkolja az adatokra való várakozást.

Metódusok

Name	Description
AuthenticateAsClient(String, X509CertificateCollection, Boolean)	Az ügyfelek a kiszolgáló és opcionálisan az ügyfél-kiszolgáló kapcsolat hitelesítésére kérik. A hitelesítési folyamat a megadott tanúsítványgyűjteményt és a rendszer alapértelmezett SSL protokollját használja.
AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)	Az ügyfelek a kiszolgáló és opcionálisan az ügyfél-kiszolgáló kapcsolat hitelesítésére kérik. A hitelesítési folyamat a megadott tanúsítványgyűjteményt és SSL-protokollt használja.
AuthenticateAsClient(String)	Az ügyfelek a kiszolgáló és opcionálisan az ügyfél-kiszolgáló kapcsolat hitelesítésére kérik.
AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)	Az ügyfelek meghívták a kiszolgáló hitelesítésére, és opcionálisan az ügyfél-kiszolgáló kapcsolatban lévő ügyfelet aszinkron műveletként. A hitelesítési folyamat a megadott tanúsítványgyűjteményt és a rendszer alapértelmezett SSL protokollját használja.
AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)	Az ügyfelek meghívták a kiszolgáló hitelesítésére, és opcionálisan az ügyfél-kiszolgáló kapcsolatban lévő ügyfelet aszinkron műveletként. A hitelesítési folyamat a megadott tanúsítványgyűjteményt és SSL-protokollt használja.
AuthenticateAsClientAsync(String)	Az ügyfelek meghívták a kiszolgáló hitelesítésére, és opcionálisan az ügyfél-kiszolgáló kapcsolatban lévő ügyfelet aszinkron műveletként.
AuthenticateAsServer(X509Certificate, Boolean, Boolean)	A kiszolgálók a megadott tanúsítványok és követelmények használatával, valamint a rendszer alapértelmezett biztonsági protokolljának használatával kérik a kiszolgáló és opcionálisan az ügyfél-kiszolgáló kapcsolaton belüli hitelesítésére.
AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)	A kiszolgálók a kiszolgáló és opcionálisan az ügyfél-kiszolgáló kapcsolaton belüli hitelesítésére kérik a megadott tanúsítványok, követelmények és biztonsági protokoll használatával.
AuthenticateAsServer(X509Certificate)	A kiszolgálók a kiszolgáló és opcionálisan az ügyfél-kiszolgáló kapcsolaton belüli hitelesítésére kérik a megadott tanúsítványt.
AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)	A kiszolgálók a kiszolgáló és opcionálisan az ügyfél-kiszolgáló kapcsolaton belüli hitelesítésére kérik a megadott tanúsítványokat, követelményeket és biztonsági protokollt aszinkron műveletként.
AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)	A kiszolgálók a kiszolgáló és opcionálisan az ügyfél-kiszolgáló kapcsolaton belüli hitelesítésére kérik a megadott tanúsítványokat, követelményeket és biztonsági protokollt aszinkron műveletként.
AuthenticateAsServerAsync(X509Certificate)	A kiszolgálók a kiszolgáló és opcionálisan az ügyfél-kiszolgáló kapcsolaton belüli hitelesítésére kérik a megadott tanúsítványt aszinkron műveletként.
BeginAuthenticateAsClient(String, AsyncCallback, Object)	Az ügyfelek meghívták, hogy kezdjenek aszinkron műveletet a kiszolgáló és opcionálisan az ügyfél hitelesítéséhez.
BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)	Az ügyfelek egy aszinkron művelet elindítására szólítják fel a kiszolgáló és opcionálisan az ügyfél hitelesítéséhez a megadott tanúsítványok és a rendszer alapértelmezett biztonsági protokollja használatával.
BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)	Az ügyfelek egy aszinkron művelet elindítására kérik a kiszolgáló és opcionálisan az ügyfél hitelesítését a megadott tanúsítványok és biztonsági protokollok használatával.
BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)	A kiszolgálók egy aszinkron művelet elindításához hívják meg az ügyfelet és opcionálisan a kiszolgálót egy ügyfél-kiszolgáló kapcsolaton belül.
BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)	A kiszolgálók meghívták egy aszinkron művelet elindítására a kiszolgáló és opcionálisan az ügyfél hitelesítéséhez a megadott tanúsítványok és követelmények, valamint a rendszer alapértelmezett biztonsági protokollja használatával.
BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)	A kiszolgálók meghívták egy aszinkron művelet elindítására a kiszolgáló és opcionálisan az ügyfél hitelesítéséhez a megadott tanúsítványok, követelmények és biztonsági protokoll használatával.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Elindít egy aszinkron olvasási műveletet, amely beolvassa az adatokat a streamből, és tárolja azokat a megadott tömbben.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Elindít egy aszinkron írási műveletet, amely a megadott pufferből a streambe írja Byteaz s-t.
Close()	Bezárja az aktuális streamet, és felszabadítja az aktuális adatfolyamhoz társított összes erőforrást (például szoftvercsatornákat és fájlfogópontokat). A metódus meghívása helyett győződjön meg arról, hogy a stream megfelelően van elosztva. (Öröklődés forrása Stream)
CopyTo(Stream, Int32)	Beolvassa a bájtokat az aktuális streamből, és egy megadott pufferméret használatával egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyTo(Stream)	Beolvassa a bájtokat az aktuális streamből, és egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Aszinkron módon beolvassa a bájtokat az aktuális streamből, és egy megadott pufferméret és lemondási jogkivonat használatával egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream, Int32)	Aszinkron módon beolvassa a bájtokat az aktuális adatfolyamból, és egy megadott puffermérettel egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream)	Aszinkron módon beolvassa a bájtokat az aktuális streamből, és egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CreateObjRef(Type)	Létrehoz egy objektumot, amely tartalmazza a távoli objektumokkal való kommunikációhoz használt proxy létrehozásához szükséges összes releváns információt. (Öröklődés forrása MarshalByRefObject)
CreateWaitHandle()	Elavult. Objektum lefoglalása WaitHandle . (Öröklődés forrása Stream)
Dispose()	Felszabadítja a .-hez használt összes erőforrást Stream. (Öröklődés forrása Stream)
Dispose(Boolean)	Felszabadítja a felügyelt erőforrások által SslStream használt nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat.
EndAuthenticateAsClient(IAsyncResult)	Befejez egy függőben lévő aszinkron kiszolgálóhitelesítési műveletet, amely egy korábbi hívással kezdődött.BeginAuthenticateAsClient
EndAuthenticateAsServer(IAsyncResult)	Befejez egy függőben lévő aszinkron ügyfél-hitelesítési műveletet, amely egy korábbi hívással kezdődött.BeginAuthenticateAsClient
EndRead(IAsyncResult)	Befejez egy aszinkron olvasási műveletet, amely egy korábbi hívással kezdődött.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)
EndWrite(IAsyncResult)	Befejez egy aszinkron írási műveletet, amely egy korábbi hívással kezdődött.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
Flush()	A pufferelt adatok az alapul szolgáló eszközre írhatók.
FlushAsync()	Aszinkron módon törli az adatfolyam összes pufferét, és a pufferelt adatokat a mögöttes eszközre írja. (Öröklődés forrása Stream)
FlushAsync(CancellationToken)	Aszinkron módon törli a stream összes pufferét, a pufferelt adatokat az alapul szolgáló eszközre írja, és figyeli a lemondási kérelmeket. (Öröklődés forrása Stream)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetLifetimeService()	Lekéri a példány élettartamszabályzatát vezérlő aktuális élettartam-szolgáltatásobjektumot. (Öröklődés forrása MarshalByRefObject)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
InitializeLifetimeService()	Beolvas egy élettartam-szolgáltatásobjektumot a példány élettartam-szabályzatának szabályozásához. (Öröklődés forrása MarshalByRefObject)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
MemberwiseClone(Boolean)	Az aktuális MarshalByRefObject objektum sekély másolatát hozza létre. (Öröklődés forrása MarshalByRefObject)
ObjectInvariant()	Elavult. Támogatja a Contract. (Öröklődés forrása Stream)
Read(Byte[], Int32, Int32)	Beolvassa az adatokat ebből a streamből, és a megadott tömbben tárolja.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Aszinkron módon beolvassa a bájtok sorozatát az aktuális adatfolyamból, az olvasási bájtok számával előrelép a streamben, és figyeli a lemondási kérelmeket. (Öröklődés forrása Stream)
ReadAsync(Byte[], Int32, Int32)	Aszinkron módon beolvassa az aktuális adatfolyamból származó bájtok sorozatát, és az olvasási bájtok számával előrelépteti a streamen belüli pozíciót. (Öröklődés forrása Stream)
ReadByte()	Beolvassa a bájtot a streamből, és egy bájttal előrelép a streamben, vagy -1 ad vissza, ha a stream végén van. (Öröklődés forrása Stream)
Seek(Int64, SeekOrigin)	Dob egy NotSupportedException.
SetLength(Int64)	Beállítja a mögöttes stream hosszát.
ShutdownAsync()	Leállítja ezt az SslStreamet.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
Write(Byte[], Int32, Int32)	Írja be a megadott számú Bytes-t a mögöttes streambe a megadott puffer és eltolás használatával.
Write(Byte[])	A megadott adatokat a streambe írja.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Aszinkron módon bájtok sorozatát írja az aktuális streambe, az aktuális pozíciót a streamen belül a megírt bájtok számával lépteti előre, és figyeli a lemondási kérelmeket. (Öröklődés forrása Stream)
WriteAsync(Byte[], Int32, Int32)	Aszinkron módon bájtok sorozatát írja az aktuális adatfolyamba, és a megírt bájtok számával előrelépteti a stream aktuális pozícióját. (Öröklődés forrása Stream)
WriteByte(Byte)	Bájtot ír a stream aktuális helyére, és egy bájttal előrelépteti a streamen belüli pozíciót. (Öröklődés forrása Stream)

Lásd még

• NegotiateStream
• AuthenticatedStream
• IOException
• Stream