SslStream Třída

Definice

Obor názvů:

System.Net.Security

Sestavení:

netstandard.dll, System.Net.Security.dll

Zdroj:

SslStream.cs

Poskytuje datový proud používaný pro komunikaci mezi klientem a serverem, který používá protokol zabezpečení SSL (Secure Socket Layer) k ověření serveru a volitelně klienta.

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

Dědičnost

Object

MarshalByRefObject

Stream

AuthenticatedStream

SslStream

Příklady

Následující příklad kódu ukazuje vytvoření TcpListener , který používá SslStream třídu ke komunikaci s klienty.

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

Následující příklad kódu ukazuje vytvoření TcpClient , který používá SslStream třídu ke komunikaci se serverem.

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

Poznámky

Protokoly SSL pomáhají poskytovat důvěrnost a kontrolu integrity zpráv přenášených pomocí SslStreamprotokolu . Při komunikaci citlivých informací mezi klientem a serverem SslStreamby se mělo použít připojení SSL, jako je například takové, které poskytuje. SslStream Použití funkce pomáhá zabránit tomu, aby kdokoli četl a manipuloval s informacemi během přenosu v síti.

Instance SslStream přenáší data pomocí datového proudu, který zadáte při vytváření SslStream. Když zadáte tento podkladový datový proud, můžete určit, zda SslStream zavření také podkladového datového proudu. Obvykle se třída SslStream používá s třídami TcpClient a TcpListener třídami. Metoda GetStream poskytuje NetworkStream vhodný pro použití s SslStream třídou.

Po vytvoření SslStreamserveru a volitelně musí být klient ověřen. Server musí poskytnout certifikát X509, který vytvoří doklad o své identitě a může požádat o to, aby to klient také udělal. Před přenosem informací pomocí SslStreamfunkce . Klienti zahájí ověřování pomocí synchronních AuthenticateAsClient metod, které blokují, dokud se ověřování nedokončí, nebo asynchronní BeginAuthenticateAsClient metody, které neblokují čekání na dokončení ověřování. Servery iniciují ověřování pomocí synchronních AuthenticateAsServer nebo asynchronních BeginAuthenticateAsServer metod. Klient i server musí zahájit ověřování.

Ověřování zpracovává poskytovatel kanálu SSPI (Security Support Provider). Klient má možnost řídit ověření certifikátu serveru zadáním delegáta RemoteCertificateValidationCallback při vytváření SslStream. Server může také řídit ověření zadáním delegáta RemoteCertificateValidationCallback . Metoda odkazovaná delegátem zahrnuje certifikát vzdálené strany a všechny chyby SSPI, ke kterým došlo při ověřování certifikátu. Všimněte si, že pokud server určuje delegáta, je vyvolána metoda delegáta bez ohledu na to, zda server požadoval ověření klienta. Pokud server nepožadoval ověření klienta, metoda delegáta serveru obdrží certifikát null a prázdné pole chyb certifikátu.

Pokud server vyžaduje ověření klienta, musí klient zadat jeden nebo více certifikátů pro ověření. Pokud má klient více než jeden certifikát, může klient poskytnout delegáta LocalCertificateSelectionCallback , který vybere správný certifikát pro server. Certifikáty klienta musí být umístěny v úložišti certifikátů "My" aktuálního uživatele. Ověřování klientů prostřednictvím certifikátů není podporováno pro Ssl2 protokol (SSL verze 2).

Pokud se ověření nezdaří, obdržíte a AuthenticationExceptionuž není možné ho SslStream použít. Tento objekt byste měli zavřít a odebrat všechny odkazy na něj, aby ho mohl shromáždit systém uvolňování paměti.

Když se proces ověřování, označovaný také jako handshake PROTOKOLU SSL, úspěšně naváže identita serveru (a volitelně i klient) a SslStream může ho použít klient a server k výměně zpráv. Před odesláním nebo příjmem informací by měl klient a server zkontrolovat služby zabezpečení a úrovně poskytované protokolem SslStream , algoritmy a silnými stránkami, které jsou vybrány, aby splňovaly své požadavky na integritu a důvěrnost. Pokud aktuální nastavení nestačí, stream by se měl zavřít. Služby zabezpečení poskytované SslStream pomocí IsEncrypted vlastností a IsSigned služeb zabezpečení můžete zkontrolovat. Následující tabulka ukazuje prvky, které hlásí kryptografické nastavení používané pro ověřování, šifrování a podepisování dat.

Element	Členové
Protokol zabezpečení používaný k ověření serveru a volitelně i klienta.	Vlastnost SslProtocol a přidružený SslProtocols výčet.
Algoritmus výměny klíčů.	Vlastnost KeyExchangeAlgorithm a přidružený ExchangeAlgorithmType výčet.
Algoritmus integrity zpráv.	Vlastnost HashAlgorithm a přidružený HashAlgorithmType výčet.
Algoritmus důvěrnosti zpráv.	Vlastnost CipherAlgorithm a přidružený CipherAlgorithmType výčet.
Silné stránky vybraných algoritmů.	The KeyExchangeStrength, HashStrengtha CipherStrength properties.

Po úspěšném ověření můžete odesílat data pomocí synchronních Write nebo asynchronních BeginWrite metod. Data můžete přijímat pomocí synchronních Read nebo asynchronních BeginRead metod.

Pokud jste zadali SslStream , že podkladový datový proud by měl zůstat otevřený, zodpovídáte za zavření datového proudu, jakmile ho použijete.

Poznámka

Pokud aplikace, která vytvoří SslStream objekt, běží s přihlašovacími údaji normálního uživatele, aplikace nebude mít přístup k certifikátům nainstalovaným v místním úložišti počítačů, pokud k tomu uživatel výslovně neudělil oprávnění.

SslStream Předpokládá, že časový limit spolu s ostatními IOException , když je vyvolán z vnitřního datového proudu, bude považován za závažnou volající. Opětovné využití SslStream instance po vypršení časového limitu vrátí uvolnění paměti. Aplikace by měla CloseSslStream v těchto případech vyvolat výjimku.

Rozhraní .NET Framework 4.6 obsahuje funkci zabezpečení, která blokuje nezabezpečené šifrovací a hashovací algoritmy pro připojení. Aplikace využívající protokol TLS/SSL prostřednictvím rozhraní API, jako jsou HttpClient, HttpWebRequest, FTPClient, SmtpClient a SslStream a cílení na rozhraní .NET Framework 4.6, ve výchozím nastavení získají bezpečnější chování.

Vývojáři můžou chtít toto chování vyloučit, aby zachovali interoperabilitu se stávajícími službami SSL3 nebo službami TLS w/ RC4. Tento článek vysvětluje, jak upravit kód tak, aby nové chování bylo zakázané.

Rozhraní .NET Framework 4.7 přidává nová přetížení pro metody, které ověřují SslStreams, které nezadávají verzi protokolu TLS, ale místo toho používají verzi PROTOKOLU TLS definovanou jako výchozí systém v SCHANNEL. Tyto metody můžete v aplikaci použít jako způsob, jak později upravit výchozí hodnoty jako osvědčené postupy při změně verze protokolu TLS v průběhu času, aniž byste museli aplikaci znovu sestavit a znovu nasadit.

Projděte si také osvědčené postupy protokolu TLS (Transport Layer Security) s rozhraním .NET Framework.

Konstruktory

Name	Description
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)	Inicializuje novou instanci SslStream třídy pomocí zadané Stream.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)	Inicializuje novou instanci SslStream třídy pomocí zadaného Streamchování , chování při uzavření datového proudu, delegát ověření certifikátu a delegát výběru certifikátu.
SslStream(Stream, Boolean, RemoteCertificateValidationCallback)	Inicializuje novou instanci SslStream třídy pomocí zadaného Streamchování , chování uzavření datového proudu a delegát ověření certifikátu.
SslStream(Stream, Boolean)	Inicializuje novou instanci SslStream třídy pomocí zadaného Stream a stream uzavření chování.
SslStream(Stream)	Inicializuje novou instanci SslStream třídy pomocí zadané Stream.

Vlastnosti

Name	Description
CanRead	Boolean Získá hodnotu, která určuje, zda je podkladový datový proud čitelný.
CanSeek	Boolean Získá hodnotu, která označuje, zda je podkladový datový proud vyhledatelný.
CanTimeout	Boolean Získá hodnotu, která označuje, zda podkladový datový proud podporuje vypršení časových limitů.
CanWrite	Boolean Získá hodnotu, která označuje, zda je podkladový datový proud zapisovatelný.
CheckCertRevocationStatus	Boolean Získá hodnotu, která označuje, zda je seznam odvolaných certifikátů kontrolován během procesu ověření certifikátu.
CipherAlgorithm	Zastaralé. Získá hodnotu, která identifikuje hromadný šifrovací algoritmus používaný tímto SslStream.
CipherStrength	Zastaralé. Získá hodnotu, která identifikuje sílu šifrovacího algoritmu používaného tímto SslStream.
HashAlgorithm	Zastaralé. Získá algoritmus používaný pro generování kódů ověřování zpráv (MAC).
HashStrength	Zastaralé. Získá hodnotu, která identifikuje sílu hash algoritmu používaného touto instancí.
InnerStream	Získá datový proud používaný tímto AuthenticatedStream způsobem pro odesílání a příjem dat. (Zděděno od AuthenticatedStream)
IsAuthenticated	Boolean Získá hodnotu, která označuje, zda ověřování bylo úspěšné.
IsEncrypted	Boolean Získá hodnotu, která označuje, zda se používá SslStream šifrování dat.
IsMutuallyAuthenticated	Boolean Získá hodnotu, která označuje, zda byl server i klient ověřen.
IsServer	Boolean Získá hodnotu, která označuje, zda místní strana připojení používaná tímto SslStream způsobem byla ověřena jako server.
IsSigned	Boolean Získá hodnotu, která označuje, zda jsou data odeslaná pomocí tohoto datového proudu podepsána.
KeyExchangeAlgorithm	Zastaralé. Získá algoritmus výměny klíčů používaný tímto SslStream.
KeyExchangeStrength	Zastaralé. Získá hodnotu, která identifikuje sílu algoritmu výměny klíčů používaný touto instancí.
LeaveInnerStreamOpen	Získá, zda datový proud používaný tímto AuthenticatedStream způsobem pro odesílání a příjem dat byl ponechán otevřený. (Zděděno od AuthenticatedStream)
Length	Získá délku podkladového datového proudu.
LocalCertificate	Získá certifikát použitý k ověření místního koncového bodu.
NegotiatedApplicationProtocol	Protokol vyjednané aplikace v protokolu TLS handshake.
NegotiatedCipherSuite	Získá šifrovací sadu, která byla pro toto připojení vyjednaná.
Position	Získá nebo nastaví aktuální pozici v podkladovém datovém proudu.
ReadTimeout	Získá nebo nastaví dobu vyjádřenou v milisekundách, bloky operace čtení čekající na data.
RemoteCertificate	Získá certifikát použitý k ověření vzdáleného koncového bodu.
SslProtocol	Získá hodnotu, která označuje protokol zabezpečení použitý k ověření tohoto připojení.
TargetHostName	Získá název serveru, ke kterému se klient pokouší připojit. Tento název se používá k ověření certifikátu serveru. Může to být název DNS nebo IP adresa.
TransportContext	TransportContext Získá použité pro ověřování pomocí rozšířené ochrany.
WriteTimeout	Získá nebo nastaví dobu, po kterou operace zápisu blokuje čekání na data.

Metody

Name	Description
AuthenticateAsClient(SslClientAuthenticationOptions)	Ověřuje server a volitelně klienta v připojení klienta-server.
AuthenticateAsClient(String, X509CertificateCollection, Boolean)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server. Proces ověřování používá zadanou kolekci certifikátů a výchozí protokol SSL systému.
AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server. Proces ověřování používá zadanou kolekci certifikátů a protokol SSL.
AuthenticateAsClient(String)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server.
AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operaci. Proces ověřování používá informace zadané v kontejneru sslClientAuthenticationOptions vlastností.
AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operaci. Proces ověřování používá zadanou kolekci certifikátů a výchozí protokol SSL systému.
AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operaci. Proces ověřování používá zadanou kolekci certifikátů a protokol SSL.
AuthenticateAsClientAsync(String)	Volali klienti pro ověření serveru a volitelně klienta v připojení klienta-server jako asynchronní operaci.
AuthenticateAsServer(SslServerAuthenticationOptions)	Volal servery pro ověření serveru a volitelně klienta v připojení klienta-server pomocí zadaného certifikátu.
AuthenticateAsServer(X509Certificate, Boolean, Boolean)	Volali servery pro ověření serveru a volitelně klienta v připojení klienta-server pomocí zadaných certifikátů a požadavků a pomocí výchozího systémového protokolu zabezpečení.
AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)	Volal servery pro ověření serveru a volitelně klienta v připojení klienta-server pomocí zadaných certifikátů, požadavků a protokolu zabezpečení.
AuthenticateAsServer(X509Certificate)	Volal servery pro ověření serveru a volitelně klienta v připojení klienta-server pomocí zadaného certifikátu.
AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken)	Volal servery pro ověření serveru a volitelně klienta v připojení klient-server jako asynchronní operace. Proces ověřování používá informace vrácené metodou optionsCallback.
AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)	Ověří server a volitelně klienta v připojení klienta-server jako asynchronní operaci. Proces ověřování používá informace zadané v kontejneru sslServerAuthenticationOptions vlastností.
AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)	Volal servery pro ověření serveru a volitelně klienta v připojení klient-server pomocí zadaných certifikátů, požadavků a protokolu zabezpečení jako asynchronní operace.
AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)	Volal servery pro ověření serveru a volitelně klienta v připojení klient-server pomocí zadaných certifikátů, požadavků a protokolu zabezpečení jako asynchronní operace.
AuthenticateAsServerAsync(X509Certificate)	Volali servery pro ověření serveru a volitelně klienta v připojení klient-server pomocí zadaného certifikátu jako asynchronní operace.
BeginAuthenticateAsClient(String, AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření serveru a volitelně klienta.
BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření serveru a volitelně klienta pomocí zadaných certifikátů a výchozího systémového protokolu zabezpečení.
BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření serveru a volitelně klienta pomocí zadaných certifikátů a protokolu zabezpečení.
BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)	Volá se servery, aby zahájily asynchronní operaci pro ověření klienta a volitelně i serveru v připojení klienta-server.
BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)	Volá se servery, aby zahájily asynchronní operaci pro ověření serveru a volitelně klienta pomocí zadaných certifikátů a požadavků a výchozího systémového protokolu zabezpečení.
BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)	Volají servery, aby zahájily asynchronní operaci pro ověření serveru a volitelně klienta pomocí zadaných certifikátů, požadavků a protokolu zabezpečení.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci čtení, která čte data z datového proudu a uloží je do zadaného pole.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Začíná asynchronní operace zápisu, která zapisuje Bytez zadané vyrovnávací paměti do datového proudu.
Close()	Zavře aktuální datový proud a uvolní všechny prostředky (například sokety a popisovače souborů) přidružené k aktuálnímu datovému proudu. Místo volání této metody se ujistěte, že je datový proud správně uvolněn. (Zděděno od Stream)
CopyTo(Stream, Int32)	Načte bajty z aktuálního datového proudu a zapíše je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyTo(Stream)	Přečte bajty z aktuálního datového proudu a zapíše je do jiného datového proudu. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadaného tokenu zrušení. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti a tokenu zrušení. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, Int32)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CreateWaitHandle()	Zastaralé. WaitHandle Přidělí objekt. (Zděděno od Stream)
Dispose()	Uvolní všechny prostředky používané nástrojem Stream. (Zděděno od Stream)
Dispose(Boolean)	Uvolní nespravované prostředky používané SslStream a volitelně uvolní spravované prostředky.
DisposeAsync()	Asynchronně uvolní nespravované a spravované prostředky používané nástrojem SslStream.
EndAuthenticateAsClient(IAsyncResult)	Ukončí čekající asynchronní operaci ověřování serveru spuštěnou s předchozím voláním BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Ukončí čekající asynchronní operaci ověřování klienta spuštěnou s předchozím voláním BeginAuthenticateAsClient.
EndRead(IAsyncResult)	Ukončí asynchronní operaci čtení spuštěnou s předchozím voláním BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Ukončí asynchronní operaci zápisu spuštěnou s předchozím voláním BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
Finalize()	Uvolní všechny prostředky používané nástrojem SslStream.
Flush()	Způsobí zápis všech dat uložených do vyrovnávací paměti do podkladového zařízení.
FlushAsync()	Asynchronně vymaže všechny vyrovnávací paměti pro tento datový proud a způsobí zápis všech dat uložených do vyrovnávací paměti do podkladového zařízení. (Zděděno od Stream)
FlushAsync(CancellationToken)	Asynchronně zapíše veškerá data uložená do vyrovnávací paměti do podkladového zařízení.
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti pro řízení zásad životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)	Vyjedná klientský certifikát u ověřeného připojení.
ObjectInvariant()	Zastaralé. Poskytuje podporu pro .Contract (Zděděno od Stream)
Read(Byte[], Int32, Int32)	Načte data z tohoto datového proudu a uloží je do zadaného pole.
Read(Span<Byte>)	Při přepsání v odvozené třídě přečte posloupnost bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně čte data z tohoto datového proudu a ukládá je v zadaném rozsahu bajtového pole.
ReadAsync(Byte[], Int32, Int32)	Asynchronně čte posloupnost bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Asynchronně čte data z tohoto datového proudu a ukládá je do zadaného rozsahu paměti.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Čte alespoň minimální počet bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Asynchronně čte alespoň minimální počet bajtů z aktuálního datového proudu, posune pozici v rámci datového proudu o počet přečtených bajtů a monitoruje žádosti o zrušení. (Zděděno od Stream)
ReadByte()	Přečte bajt z bajtu SslStream a posune pozici v datovém proudu o jeden bajt nebo vrátí -1, pokud je na konci datového proudu.
ReadExactly(Byte[], Int32, Int32)	count Přečte počet bajtů z aktuálního datového proudu a posune pozici v rámci datového proudu. (Zděděno od Stream)
ReadExactly(Span<Byte>)	Přečte bajty z aktuálního datového proudu a posune pozici v rámci datového proudu, dokud buffer se nenaplní. (Zděděno od Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně čte count počet bajtů z aktuálního datového proudu, posune pozici v rámci datového proudu a monitoruje požadavky na zrušení. (Zděděno od Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu, posune pozici v rámci datového proudu, dokud buffer se nenaplní, a monitoruje žádosti o zrušení. (Zděděno od Stream)
Seek(Int64, SeekOrigin)	Vyhodí .NotSupportedException
SetLength(Int64)	Nastaví délku podkladového datového proudu.
ShutdownAsync()	Vypne tento SslStream.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
Write(Byte[], Int32, Int32)	Pomocí zadané vyrovnávací paměti a posunu napište zadaný počet Bytes do podkladového datového proudu.
Write(Byte[])	Zapíše zadaná data do tohoto datového proudu.
Write(ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě zapíše posloupnost bajtů do aktuálního datového proudu a posune aktuální pozici v tomto datovém proudu počtem zapsaných bajtů.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně zapisuje data do podkladového datového proudu ze zadané oblasti pole bajtů.
WriteAsync(Byte[], Int32, Int32)	Asynchronně zapíše posloupnost bajtů do aktuálního datového proudu a posune aktuální pozici v tomto datovém proudu o počet zapsaných bajtů. (Zděděno od Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Asynchronně zapisuje data do podkladového datového proudu z rozsahu paměti jen pro čtení.
WriteByte(Byte)	Zapíše bajt na aktuální pozici v datovém proudu a posune pozici v rámci datového proudu o jeden bajt.

Metody rozšíření

Name	Description
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguruje, jak čekají na úlohy vrácené z asynchronního jednorázového použití.
CopyToAsync(Stream, PipeWriter, CancellationToken)	Asynchronně čte bajty ze zadaného objektu Stream a zapíše je do zadaného PipeWritertokenu zrušení.

Viz také

• NegotiateStream
• AuthenticatedStream
• IOException
• Stream