SslStream 類別

定義

命名空間:

System.Net.Security

組件:

System.Net.Security.dll

來源:

SslStream.cs

提供用於用戶端-伺服器通訊的數據流，該數據流會使用安全套接字層 （SSL） 安全性通訊協定來驗證伺服器，並選擇性地驗證用戶端。

C#

public class SslStream : System.Net.Security.AuthenticatedStream

繼承

Object

MarshalByRefObject

Stream

AuthenticatedStream

SslStream

範例

下列程式代碼範例示範如何建立使用 SslStream 類別來與用戶端通訊的 TcpListener。

C#

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;
        }
    }
}

下列程式代碼範例示範如何建立使用 SslStream 類別與伺服器通訊的 TcpClient。

C#

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;
        }
    }
}

備註

SSL 通訊協議有助於提供使用 SslStream傳輸之訊息的機密性和完整性檢查。 在用戶端與伺服器之間通訊敏感性資訊時，應該使用 SSL 連線，例如 SslStream所提供的 SSL 連線。 使用 SslStream 有助於防止任何人在網路上傳輸時讀取和竄改資訊。

SslStream 實例會使用您在建立 SslStream時提供的數據流來傳輸數據。 當您提供此基礎數據流時，可以選擇指定是否關閉 SslStream 也會關閉基礎數據流。 一般而言，SslStream 類別會與 TcpClient 和 TcpListener 類別搭配使用。 GetStream 方法提供適合與 SslStream 類別搭配使用的 NetworkStream。

建立 SslStream之後，伺服器和選擇性地必須驗證用戶端。 伺服器必須提供 X509 憑證，以建立其身分識別的證明，並可要求用戶端也這樣做。 必須先執行驗證，才能使用 SslStream傳輸資訊。 用戶端會使用同步 AuthenticateAsClient 方法來起始驗證，此方法會封鎖直到驗證完成為止，或異步 BeginAuthenticateAsClient 方法，而不會封鎖等候驗證完成。 伺服器會使用同步 AuthenticateAsServer 或異步 BeginAuthenticateAsServer 方法來起始驗證。 用戶端和伺服器都必須起始驗證。

驗證是由安全性支援提供者 （SSPI） 通道提供者處理。 用戶端有機會在建立 SslStream時指定 RemoteCertificateValidationCallback 委派，以控制伺服器的憑證驗證。 伺服器也可以藉由提供 RemoteCertificateValidationCallback 委派來控制驗證。 委派所參考的方法包含遠端合作對象的憑證，以及驗證憑證時遇到的任何 SSPI 錯誤。 請注意，如果伺服器指定委派，不論伺服器是否要求客戶端驗證，都會叫用委派的方法。 如果伺服器未要求客戶端驗證，伺服器的委派方法會收到 Null 憑證和空的憑證錯誤數位。

如果伺服器需要客戶端驗證，客戶端必須指定一或多個憑證進行驗證。 如果用戶端有多個憑證，用戶端可以提供 LocalCertificateSelectionCallback 委派，以選取伺服器的正確憑證。 用戶端的憑證必須位於目前使用者的「我的」證書存儲中。 Ssl2 （SSL 第 2 版） 通訊協定不支援透過憑證進行客戶端驗證。

如果驗證失敗，您會收到 AuthenticationException，且 SslStream 已無法使用。 您應該關閉這個物件，並移除它的所有參考，讓垃圾收集行程可以收集它。

當驗證程式也稱為 SSL 交握時，會成功建立伺服器身分識別（以及選擇性地建立用戶端），而且客戶端和伺服器可以使用 SslStream 來交換訊息。 傳送或接收資訊之前，客戶端和伺服器應該檢查 SslStream 所提供的安全性服務和層級，以判斷選取的通訊協定、演算法和強度是否符合其完整性和機密性需求。 如果目前的設定不足，應該關閉數據流。 您可以使用 IsEncrypted 和 IsSigned 屬性來檢查 SslStream 所提供的安全性服務。 下表顯示報告用於驗證、加密和數據簽署之密碼編譯設定的專案。

元素	成員
用來驗證伺服器的安全性通訊協定，以及選擇性地驗證用戶端。	SslProtocol 屬性和相關聯的 SslProtocols 列舉。
金鑰交換演算法。	KeyExchangeAlgorithm 屬性和相關聯的 ExchangeAlgorithmType 列舉。
訊息完整性演算法。	HashAlgorithm 屬性和相關聯的 HashAlgorithmType 列舉。
訊息機密性演算法。	CipherAlgorithm 屬性和相關聯的 CipherAlgorithmType 列舉。
所選演算法的優點。	KeyExchangeStrength、HashStrength和 CipherStrength 屬性。

成功驗證之後，您可以使用同步 Write 或異步 BeginWrite 方法來傳送數據。 您可以使用同步 Read 或異步 BeginRead 方法來接收數據。

如果您指定給 SslStream 基礎資料流應該保持開啟狀態，您必須負責在完成使用該數據流時關閉該資料流。

備註

如果建立 SslStream 物件的應用程式會以 Normal 使用者的認證執行，除非已明確將許可權授與使用者，否則應用程式將無法存取本機電腦存放區中安裝的憑證。

SslStream 假設當從內部數據流擲回時，逾時與其他任何 IOException 都會由其呼叫端視為嚴重。 逾時之後重複使用 SslStream 實例會傳回垃圾。 應用程式應該 CloseSslStream，並在這些情況下擲回例外狀況。

.NET Framework 4.6 包含新的安全性功能，可封鎖連線不安全的加密和哈希演算法。 透過 HTTPClient、HttpWebRequest、FTPClient、SmtpClient、SslStream 等 API 使用 TLS/SSL 的應用程式，以及以 .NET Framework 4.6 為目標的應用程式預設會取得更安全的行為。

開發人員可能會想要退出退出此行為，以維持與其現有 SSL3 服務或 TLS w/ RC4 服務的互操作性。 本文 說明如何修改程序代碼，以便停用新的行為。

.NET Framework 4.7 會為驗證未指定 TLS 版本的 SslStreams 的方法新增多載，但改用定義為 SCHANNEL 中系統預設值的 TLS 版本。 在應用程式中使用這些方法作為稍後能夠修改預設值的方式，因為 TLS 版本最佳做法會隨著時間而變更，而不需要重建和重新部署您的應用程式。

另請參閱使用 .NET Framework傳輸層安全性 （TLS） 最佳做法。

建構函式

SslStream(Stream)	使用指定的 Stream，初始化 SslStream 類別的新實例。
SslStream(Stream, Boolean)	使用指定的 Stream 和數據流關閉行為，初始化 SslStream 類別的新實例。
SslStream(Stream, Boolean, RemoteCertificateValidationCallback)	使用指定的 Stream、數據流關閉行為和憑證驗證委派，初始化 SslStream 類別的新實例。
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)	使用指定的 Stream、數據流關閉行為、憑證驗證委派和憑證選取委派，初始化 SslStream 類別的新實例。
SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)	使用指定的 Stream，初始化 SslStream 類別的新實例。

屬性

CanRead	取得 Boolean 值，指出基礎數據流是否可讀取。
CanSeek	取得 Boolean 值，指出是否可搜尋基礎數據流。
CanTimeout	取得 Boolean 值，指出基礎數據流是否支援逾時。
CanWrite	取得 Boolean 值，指出基礎數據流是否可寫入。
CheckCertRevocationStatus	取得 Boolean 值，指出憑證驗證程序期間是否檢查證書吊銷清單。
CipherAlgorithm	取得值，這個值會識別這個 SslStream所使用的大量加密演算法。
CipherStrength	取得值，這個值會識別這個 SslStream所使用的加密演算法強度。
HashAlgorithm	取得用來產生訊息驗證碼 （MAC） 的演算法。
HashStrength	取得值，這個值會識別這個實例所使用的哈希演算法強度。
InnerStream	取得這個 AuthenticatedStream 用於傳送和接收數據的數據流。 (繼承來源 AuthenticatedStream)
IsAuthenticated	取得 Boolean 值，指出驗證是否成功。
IsEncrypted	取得 Boolean 值，指出這個 SslStream 是否使用數據加密。
IsMutuallyAuthenticated	取得 Boolean 值，指出是否已驗證伺服器和用戶端。
IsServer	取得 Boolean 值，指出這個 SslStream 所使用的連接本機端是否已驗證為伺服器。
IsSigned	取得 Boolean 值，指出是否使用此數據流傳送的數據已簽署。
KeyExchangeAlgorithm	取得這個 SslStream所使用的金鑰交換演算法。
KeyExchangeStrength	取得值，這個值會識別這個實例所使用的密鑰交換演演算法強度。
LeaveInnerStreamOpen	取得這個 AuthenticatedStream 用於傳送和接收數據的數據流是否已保持開啟狀態。 (繼承來源 AuthenticatedStream)
Length	取得基礎數據流的長度。
LocalCertificate	取得用來驗證本機端點的憑證。
NegotiatedApplicationProtocol	TLS 交握中交涉的應用程式通訊協定。
NegotiatedCipherSuite	取得為這個連接交涉的加密套件。
Position	取得或設定基礎數據流中的目前位置。
ReadTimeout	取得或設定等候數據的讀取作業區塊，以毫秒表示的時間量。
RemoteCertificate	取得用來驗證遠端端端點的憑證。
SslProtocol	取得值，這個值表示用來驗證此連線的安全性通訊協定。
TargetHostName	取得客戶端嘗試連線的伺服器名稱。 該名稱用於伺服器證書驗證。 它可以是 DNS 名稱或 IP 位址。
TransportContext	取得用於使用擴充保護進行驗證的 TransportContext。
WriteTimeout	取得或設定寫入作業封鎖等候數據的時間量。

方法

AuthenticateAsClient(SslClientAuthenticationOptions)	用戶端呼叫以驗證伺服器，並選擇性地驗證客戶端-伺服器連線中的用戶端。
AuthenticateAsClient(String)	用戶端呼叫以驗證伺服器，並選擇性地驗證客戶端-伺服器連線中的用戶端。
AuthenticateAsClient(String, X509CertificateCollection, Boolean)	用戶端呼叫以驗證伺服器，並選擇性地驗證客戶端-伺服器連線中的用戶端。 驗證程式會使用指定的憑證集合，以及系統預設的 SSL 通訊協定。
AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)	用戶端呼叫以驗證伺服器，並選擇性地驗證客戶端-伺服器連線中的用戶端。 驗證程式會使用指定的憑證集合和 SSL 通訊協定。
AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)	用戶端呼叫以驗證伺服器，並選擇性地驗證客戶端-伺服器連線中的用戶端做為異步操作。 驗證程式會使用 sslClientAuthenticationOptions 屬性包中指定的資訊。
AuthenticateAsClientAsync(String)	用戶端呼叫以驗證伺服器，並選擇性地驗證客戶端-伺服器連線中的用戶端做為異步操作。
AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)	用戶端呼叫以驗證伺服器，並選擇性地驗證客戶端-伺服器連線中的用戶端做為異步操作。 驗證程式會使用指定的憑證集合和系統預設 SSL 通訊協定。
AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)	用戶端呼叫以驗證伺服器，並選擇性地驗證客戶端-伺服器連線中的用戶端做為異步操作。 驗證程式會使用指定的憑證集合和 SSL 通訊協定。
AuthenticateAsServer(SslServerAuthenticationOptions)	由伺服器呼叫，以使用指定的憑證，在用戶端-伺服器連線中選擇性地驗證伺服器和用戶端。
AuthenticateAsServer(X509Certificate)	由伺服器呼叫，以使用指定的憑證，在用戶端-伺服器連線中選擇性地驗證伺服器和用戶端。
AuthenticateAsServer(X509Certificate, Boolean, Boolean)	由伺服器呼叫，以使用指定的憑證和需求，以及使用系統預設安全性通訊協定，在用戶端-伺服器連線中選擇性地驗證伺服器和用戶端。
AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)	由伺服器呼叫，以使用指定的憑證、需求和安全性通訊協定，在用戶端-伺服器連線中選擇性地驗證伺服器和用戶端。
AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken)	由伺服器呼叫，以驗證伺服器，並選擇性地驗證客戶端-伺服器連線中的用戶端作為異步操作。 驗證程式會使用 optionsCallback傳回的資訊。
AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)	由伺服器呼叫，以驗證伺服器，並選擇性地驗證客戶端-伺服器連線中的用戶端作為異步操作。 驗證程式會使用 sslClientAuthenticationOptions 屬性包中指定的資訊。
AuthenticateAsServerAsync(X509Certificate)	由伺服器呼叫，以使用指定的憑證作為異步操作，在用戶端-伺服器連線中選擇性地驗證伺服器和用戶端。
AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)	由伺服器呼叫，以使用指定的憑證、需求和安全性通訊協定作為異步操作，在用戶端-伺服器聯機中選擇性地驗證伺服器和用戶端。
AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)	由伺服器呼叫，以使用指定的憑證、需求和安全性通訊協定作為異步操作，在用戶端-伺服器聯機中選擇性地驗證伺服器和用戶端。
BeginAuthenticateAsClient(String, AsyncCallback, Object)	用戶端呼叫以開始異步操作，以驗證伺服器，並選擇性地驗證用戶端。
BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)	用戶端呼叫以開始異步操作，以使用指定的憑證和系統預設安全性通訊協議來驗證伺服器，以及選擇性地驗證用戶端。
BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)	用戶端呼叫以開始異步操作，以使用指定的憑證和安全性通訊協議來驗證伺服器，以及選擇性地驗證用戶端。
BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)	由伺服器呼叫以開始異步操作，以驗證用戶端，並選擇性地在用戶端-伺服器連線中驗證伺服器。
BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)	由伺服器呼叫以開始異步操作，以使用指定的憑證和需求，以及系統預設安全性通訊協定來驗證伺服器，以及選擇性地驗證用戶端。
BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)	由伺服器呼叫以開始異步操作，以使用指定的憑證、需求和安全性通訊協定來驗證伺服器，以及選擇性地驗證用戶端。
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	開始異步讀取作業，從數據流讀取數據，並將其儲存在指定的陣列中。
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	開始異步寫入作業，將 Byte從指定的緩衝區寫入數據流。
Close()	關閉目前的數據流，並釋放與目前數據流相關聯的任何資源（例如套接字和檔句柄）。 請確定已正確處置數據流，而不是呼叫此方法。 (繼承來源 Stream)
CopyTo(Stream)	從目前的數據流讀取位元組，並將其寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。 (繼承來源 Stream)
CopyTo(Stream, Int32)	從目前的數據流讀取位元組，並使用指定的緩衝區大小將它們寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。 (繼承來源 Stream)
CopyToAsync(Stream)	以異步方式從目前的數據流讀取位元組，並將其寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。 (繼承來源 Stream)
CopyToAsync(Stream, CancellationToken)	使用指定的取消標記，以異步方式從目前數據流讀取位元組，並將其寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。 (繼承來源 Stream)
CopyToAsync(Stream, Int32)	使用指定的緩衝區大小，以異步方式從目前數據流讀取位元組，並將其寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。 (繼承來源 Stream)
CopyToAsync(Stream, Int32, CancellationToken)	使用指定的緩衝區大小和取消標記，以異步方式從目前數據流讀取位元組，並將其寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。 (繼承來源 Stream)
CreateObjRef(Type)	建立物件，其中包含產生用來與遠端物件通訊之 Proxy 所需的所有相關信息。 (繼承來源 MarshalByRefObject)
CreateWaitHandle()	已淘汰. 配置 WaitHandle 物件。 (繼承來源 Stream)
Dispose()	釋放 Stream所使用的所有資源。 (繼承來源 Stream)
Dispose(Boolean)	釋放 SslStream 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。
DisposeAsync()	以異步方式釋放 SslStream所使用的 Unmanaged 和 Managed 資源。
EndAuthenticateAsClient(IAsyncResult)	結束擱置中的異步伺服器驗證作業，且先前呼叫 BeginAuthenticateAsClient。
EndAuthenticateAsServer(IAsyncResult)	結束擱置中的異步客戶端驗證作業，此作業以先前呼叫 BeginAuthenticateAsClient開始。
EndRead(IAsyncResult)	結束異步讀取作業，且先前呼叫 BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)。
EndWrite(IAsyncResult)	結束以先前呼叫 BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)開始的異步寫入作業。
Equals(Object)	判斷指定的物件是否等於目前的物件。 (繼承來源 Object)
Finalize()	釋放 SslStream所使用的所有資源。
Flush()	造成任何緩衝數據寫入基礎裝置。
FlushAsync()	以異步方式清除此數據流的所有緩衝區，並導致任何緩衝的數據寫入基礎裝置。 (繼承來源 Stream)
FlushAsync(CancellationToken)	以異步方式將任何緩衝的數據寫入基礎裝置。
GetHashCode()	做為預設哈希函式。 (繼承來源 Object)
GetLifetimeService()	已淘汰. 擷取控制這個實例存留期原則的目前存留期服務物件。 (繼承來源 MarshalByRefObject)
GetType()	取得目前實例的 Type。 (繼承來源 Object)
InitializeLifetimeService()	已淘汰. 取得存留期服務物件，以控制這個實例的存留期原則。 (繼承來源 MarshalByRefObject)
MemberwiseClone()	建立目前 Object的淺層複本。 (繼承來源 Object)
MemberwiseClone(Boolean)	建立目前 MarshalByRefObject 對象的淺層複本。 (繼承來源 MarshalByRefObject)
NegotiateClientCertificateAsync(CancellationToken)	交涉已驗證連線上的客戶端憑證。
ObjectInvariant()	已淘汰. 提供 Contract的支援。 (繼承來源 Stream)
Read(Byte[], Int32, Int32)	從這個數據流讀取數據，並將它儲存在指定的陣列中。
Read(Span<Byte>)	在衍生類別中覆寫時，從目前數據流讀取位元組序列，並將數據流中的位置依讀取的位元組數目往前移。 (繼承來源 Stream)
ReadAsync(Byte[], Int32, Int32)	以異步方式從目前數據流讀取位元組序列，並依讀取的位元元組數目將數據流中的位置往前移。 (繼承來源 Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	以異步方式從這個數據流讀取數據，並將其儲存在位元組陣列的指定範圍內。
ReadAsync(Memory<Byte>, CancellationToken)	以異步方式從這個數據流讀取數據，並將其儲存在指定的記憶體範圍中。
ReadAtLeast(Span<Byte>, Int32, Boolean)	從目前數據流讀取至少一個字節數目，並將數據流中的位置依讀取的位元組數目往前移。 (繼承來源 Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	以異步方式從目前數據流讀取至少一個字節數目、依讀取的位元組數目將數據流中的位置往前移，並監視取消要求。 (繼承來源 Stream)
ReadByte()	從 SslStream 讀取位元組，並將數據流中的位置往前移一個字節，或在數據流結尾處傳回 -1。
ReadExactly(Byte[], Int32, Int32)	從目前數據流讀取 count 位元組數，並將位置往前移。 (繼承來源 Stream)
ReadExactly(Span<Byte>)	從目前的數據流讀取位元組，並將位置往前移，直到填入 buffer 為止。 (繼承來源 Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	以異步方式從目前數據流讀取 count 位元組數目、推進數據流中的位置，以及監視取消要求。 (繼承來源 Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	以異步方式從目前數據流讀取位元組、將數據流中的位置往前移，直到填入 buffer，並監視取消要求。 (繼承來源 Stream)
Seek(Int64, SeekOrigin)	擲回 NotSupportedException。
SetLength(Int64)	設定基礎數據流的長度。
ShutdownAsync()	關閉此 SslStream。
ToString()	傳回表示目前 物件的字串。 (繼承來源 Object)
Write(Byte[])	將指定的數據寫入此數據流。
Write(Byte[], Int32, Int32)	使用指定的緩衝區和位移，將指定的 Byte數目寫入基礎數據流。
Write(ReadOnlySpan<Byte>)	在衍生類別中覆寫時，將位元組序列寫入目前數據流，並依寫入的位元組數目將這個數據流中的目前位置往前移。 (繼承來源 Stream)
WriteAsync(Byte[], Int32, Int32)	以異步方式將位元組序列寫入目前數據流，並依寫入的位元元組數目，將這個數據流中的目前位置往前移。 (繼承來源 Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	從位元組陣列的指定範圍，以異步方式將數據寫入基礎數據流。
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	以異步方式將數據從唯讀位元組記憶體範圍寫入基礎數據流。
WriteByte(Byte)	將位元組寫入數據流中的目前位置，並將數據流中的位置往前移一個字節。 (繼承來源 Stream)

擴充方法

CopyToAsync(Stream, PipeWriter, CancellationToken)	使用取消標記，以異步方式從 Stream 讀取位元組，並將其寫入指定的 PipeWriter。
ConfigureAwait(IAsyncDisposable, Boolean)	設定如何執行從異步可處置專案傳回的工作等候。

適用於

另請參閱

• NegotiateStream
• AuthenticatedStream
• IOException
• Stream