SslStream 클래스

참조

정의

네임스페이스:: System.Net.Security

어셈블리:: System.Net.Security.dll

어셈블리:: System.dll

어셈블리:: netstandard.dll

Source:: SslStream.cs

Source:: SslStream.cs

Source:: SslStream.cs

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

SSL(Secure Socket Layer) 보안 프로토콜을 사용하여 서버 및 선택적으로 클라이언트를 인증하는 클라이언트-서버 통신에 사용되는 스트림을 제공합니다.

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

상속: Object

Stream

AuthenticatedStream
SslStream

상속: Object

MarshalByRefObject

Stream

AuthenticatedStream
SslStream

예제

다음 코드 예제에서는 SslStream 클래스를 사용하여 클라이언트와 통신하는 TcpListener 만드는 방법을 보여 줍니다.

#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Net;
using namespace System::Net::Sockets;
using namespace System::Net::Security;
using namespace System::Security::Authentication;
using namespace System::Text;
using namespace System::Security::Cryptography::X509Certificates;
using namespace System::IO;
public ref class SslTcpServer sealed
{
private:
   static X509Certificate^ serverCertificate = nullptr;

public:

   // The certificate parameter specifies the name of the file 
   // containing the machine certificate.
   static void RunServer( String^ certificate )
   {
      serverCertificate = X509Certificate::CreateFromCertFile( certificate );
      
      // Create a TCP/IP (IPv4) socket and listen for incoming connections.
      TcpListener^ listener = gcnew TcpListener( IPAddress::Any,5000 );
      listener->Start();
      
      while (true) 
      {
         Console::WriteLine( L"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 = gcnew SslStream( client->GetStream(),false );
      
      // Authenticate the server but don't require the client to authenticate.
      try
      {
         sslStream->AuthenticateAsServer( serverCertificate, false, true );
         // false == no client cert required; true == check cert revocation.
         
         // 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( L"Waiting for client message..." );
         String^ messageData = ReadMessage( sslStream );
         Console::WriteLine( L"Received: {0}", messageData );
         
         // Write a message to the client.
         array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the server.<EOF>" );
         Console::WriteLine( L"Sending hello message." );
         sslStream->Write( message );
      }
      catch ( AuthenticationException^ e ) 
      {
         Console::WriteLine( L"Exception: {0}", e->Message );
         if ( e->InnerException != nullptr )
         {
            Console::WriteLine( L"Inner exception: {0}", e->InnerException->Message );
         }
         Console::WriteLine( L"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.
      array<Byte>^buffer = gcnew array<Byte>(2048);
      StringBuilder^ messageData = gcnew 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();
         array<Char>^chars = gcnew array<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( L"<EOF>" ) != -1 )
         {
            break;
         }
      }
      while ( bytes != 0 );

      return messageData->ToString();
   }


   static void DisplaySecurityLevel( SslStream^ stream )
   {
      Console::WriteLine( L"Cipher: {0} strength {1}", stream->CipherAlgorithm, stream->CipherStrength );
      Console::WriteLine( L"Hash: {0} strength {1}", stream->HashAlgorithm, stream->HashStrength );
      Console::WriteLine( L"Key exchange: {0} strength {1}", stream->KeyExchangeAlgorithm, stream->KeyExchangeStrength );
      Console::WriteLine( L"Protocol: {0}", stream->SslProtocol );
   }


   static void DisplaySecurityServices( SslStream^ stream )
   {
      Console::WriteLine( L"Is authenticated: {0} as server? {1}", stream->IsAuthenticated, stream->IsServer );
      Console::WriteLine( L"IsSigned: {0}", stream->IsSigned );
      Console::WriteLine( L"Is Encrypted: {0}", stream->IsEncrypted );
      Console::WriteLine( L"Is mutually authenticated: {0}", stream->IsMutuallyAuthenticated );
   }


   static void DisplayStreamProperties( SslStream^ stream )
   {
      Console::WriteLine( L"Can read: {0}, write {1}", stream->CanRead, stream->CanWrite );
      Console::WriteLine( L"Can timeout: {0}", stream->CanTimeout );
   }


   static void DisplayCertificateInformation( SslStream^ stream )
   {
      Console::WriteLine( L"Certificate revocation list checked: {0}", stream->CheckCertRevocationStatus );
      X509Certificate^ localCertificate = stream->LocalCertificate;
      if ( stream->LocalCertificate != nullptr )
      {
         Console::WriteLine( L"Local cert was issued to {0} and is valid from {1} until {2}.", 
             localCertificate->Subject, 
             localCertificate->GetEffectiveDateString(), 
             localCertificate->GetExpirationDateString() );
      }
      else
      {
         Console::WriteLine( L"Local certificate is null." );
      }

      X509Certificate^ remoteCertificate = stream->RemoteCertificate;
      if ( stream->RemoteCertificate != nullptr )
      {
         Console::WriteLine( L"Remote cert was issued to {0} and is valid from {1} until {2}.", 
            remoteCertificate->Subject, 
            remoteCertificate->GetEffectiveDateString(), 
            remoteCertificate->GetExpirationDateString() );
      }
      else
      {
         Console::WriteLine( L"Remote certificate is null." );
      }
   }


private:

   static void DisplayUsage()
   {
      Console::WriteLine( L"To start the server specify:" );
      Console::WriteLine( L"serverSync certificateFile.cer" );
      Environment::Exit( 1 );
   }

public:
   int RunServerASync()
   {
      array<String^>^args = Environment::GetCommandLineArgs();
      String^ certificate = nullptr;
      if ( args == nullptr || args->Length < 2 )
      {
         DisplayUsage();
      }

      certificate = args[ 1 ];
      SslTcpServer::RunServer( certificate );
      return 0;
   }

};

int main(){
    SslTcpServer^ sts = gcnew SslTcpServer();
    sts->RunServerASync();
}

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

다음 코드 예제에서는 SslStream 클래스를 사용하여 서버와 통신하는 TcpClient 만드는 방법을 보여 줍니다.

#using <System.dll>
#using <System.Security.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Security::Authentication;
using namespace System::Text;
using namespace System::Security::Cryptography::X509Certificates;
using namespace System::IO;

namespace NlsClientSync
{
    public ref class SslTcpClient
    {
    private:
        static Hashtable^ certificateErrors = gcnew Hashtable;
        // Load a table of errors that might cause 
        // the certificate authentication to fail.
        static void InitializeCertificateErrors()
        {
            certificateErrors->Add(0x800B0101,
                "The certification has expired.");
            certificateErrors->Add(0x800B0104,
                "A path length constraint "
                "in the certification chain has been violated.");
            certificateErrors->Add(0x800B0105,
                "A certificate contains an unknown extension "
                "that is marked critical.");
            certificateErrors->Add(0x800B0107,
                "A parent of a given certificate in fact "
                "did not issue that child certificate.");
            certificateErrors->Add(0x800B0108,
                "A certificate is missing or has an empty value "
                "for a necessary field.");
            certificateErrors->Add(0x800B0109,
                "The certificate root is not trusted.");
            certificateErrors->Add(0x800B010C,
                "The certificate has been revoked.");
            certificateErrors->Add(0x800B010F,
                "The name in the certificate does not not match "
                "the host name requested by the client.");
            certificateErrors->Add(0x800B0111,
                "The certificate was explicitly marked "
                "as untrusted by the user.");
            certificateErrors->Add(0x800B0112,
                "A certification chain processed correctly, "
                "but one of the CA certificates is not trusted.");
            certificateErrors->Add(0x800B0113,
                "The certificate has an invalid policy.");
            certificateErrors->Add(0x800B0114,
                "The certificate name is either not "
                "in the permitted list or is explicitly excluded.");
            certificateErrors->Add(0x80092012,
                "The revocation function was unable to check "
                "revocation for the certificate.");
            certificateErrors->Add(0x80090327,
                "An unknown error occurred while "
                "processing the certificate.");
            certificateErrors->Add(0x80096001,
                "A system-level error occurred "
                "while verifying trust.");
            certificateErrors->Add(0x80096002,
                "The certificate for the signer of the message "
                "is invalid or not found.");
            certificateErrors->Add(0x80096003,
                "One of the counter signatures was invalid.");
            certificateErrors->Add(0x80096004,
                "The signature of the certificate "
                "cannot be verified.");
            certificateErrors->Add(0x80096005,
                "The time stamp signature or certificate "
                "could not be verified or is malformed.");
            certificateErrors->Add(0x80096010,
                "The digital signature of the object "
                "was not verified.");
            certificateErrors->Add(0x80096019,
                "The basic constraint extension of a certificate "
                "has not been observed.");
        }

        static String^ CertificateErrorDescription(UInt32 problem)
        {
            // Initialize the error message dictionary 
            // if it is not yet available.
            if (certificateErrors->Count == 0)
            {
                InitializeCertificateErrors();
            }

            String^ description = safe_cast<String^>(
                certificateErrors[problem]);
            if (description == nullptr)
            {
                description = String::Format(
                    CultureInfo::CurrentCulture,
                    "Unknown certificate error - 0x{0:x8}",
                    problem);
            }

            return description;
        }

    public:
        // The following method is invoked 
        // by the CertificateValidationDelegate.
    static bool ValidateServerCertificate(
            Object^ sender,
            X509Certificate^ certificate,
            X509Chain^ chain,
            SslPolicyErrors sslPolicyErrors)
        {
        
            Console::WriteLine("Validating the server certificate.");
            if (sslPolicyErrors == SslPolicyErrors::None)
                return true;

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

            // Do not allow this client to communicate with unauthenticated servers.
            return false;
        }

        static void RunClient(String^ machineName, String^ serverName)
        {
              
            // Create a TCP/IP client socket.
            // machineName is the host running the server application.
            TcpClient^ client = gcnew TcpClient(machineName, 5000);
            Console::WriteLine("Client connected.");
              
            // Create an SSL stream that will close 
            // the client's stream.
            SslStream^ sslStream = gcnew SslStream(
                client->GetStream(), false,
                gcnew RemoteCertificateValidationCallback(ValidateServerCertificate),
                nullptr);
              
            // The server name must match the name
            // on the server certificate.
            try
            {
                sslStream->AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException^ ex) 
            {
                Console::WriteLine("Exception: {0}", ex->Message);
                if (ex->InnerException != nullptr)
                {
                    Console::WriteLine("Inner exception: {0}", 
                        ex->InnerException->Message);
                }

                Console::WriteLine("Authentication failed - "
                    "closing the connection.");
                sslStream->Close();
                client->Close();
                return;
            }
            // Encode a test message into a byte array.
            // Signal the end of the message using the "<EOF>".
            array<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.
            sslStream->Close();
            client->Close();
            Console::WriteLine("Client closed.");
        }
    private:
        static String^ ReadMessage(SslStream^ sslStream)
        {
              
            // Read the  message sent by the server.
            // The end of the message is signaled using the
            // "<EOF>" marker.
            array<Byte>^ buffer = gcnew array<Byte>(2048);
            StringBuilder^ messageData = gcnew StringBuilder;
            // Use Decoder class to convert from bytes to UTF8
            // in case a character spans two buffers.
            Encoding^ u8 = Encoding::UTF8;
            Decoder^ decoder = u8->GetDecoder();

            int bytes = -1;
            do
            {
                bytes = sslStream->Read(buffer, 0, buffer->Length);
                 
                array<__wchar_t>^ chars = gcnew array<__wchar_t>(
                    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();
        }
    };
}

int main()
{
    array<String^>^ args = Environment::GetCommandLineArgs();
    String^ serverCertificateName = nullptr;
    String^ machineName = nullptr;
    if (args == nullptr || args->Length < 2)
    {
        Console::WriteLine("To start the client specify:");
        Console::WriteLine("clientSync machineName [serverName]");
        return 1;
    }
        
    // User can specify the machine name and server name.
    // Server name must match the name on 
    // the server's certificate.
    machineName = args[1];
    if (args->Length < 3)
    {
        serverCertificateName = machineName;
    }
    else
    {
        serverCertificateName = args[2];
    };

    NlsClientSync::SslTcpClient::RunClient(machineName,
        serverCertificateName);

    return 0;
}

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

설명

SSL 프로토콜은 SslStream사용하여 전송되는 메시지에 대한 기밀성 및 무결성 검사를 제공하는 데 도움이 됩니다. SslStream제공하는 것과 같은 SSL 연결은 클라이언트와 서버 간에 중요한 정보를 전달할 때 사용해야 합니다. SslStream 사용하면 네트워크에서 전송하는 동안 모든 사용자가 정보를 읽고 변조하는 것을 방지할 수 있습니다.

SslStream 인스턴스는 SslStream만들 때 제공하는 스트림을 사용하여 데이터를 전송합니다. 이 기본 스트림을 제공하는 경우 SslStream 닫을 때 기본 스트림도 닫을지 여부를 지정하는 옵션이 있습니다. 일반적으로 SslStream 클래스는 TcpClient 및 TcpListener 클래스와 함께 사용됩니다. GetStream 메서드는 SslStream 클래스에 사용하기에 적합한 NetworkStream 제공합니다.

SslStream만든 후 서버와 필요에 따라 클라이언트를 인증해야 합니다. 서버는 해당 ID의 증명을 설정하고 클라이언트도 그렇게 되도록 요청할 수 있는 X509 인증서를 제공해야 합니다. SslStream사용하여 정보를 전송하기 전에 인증을 수행해야 합니다. 클라이언트는 인증이 완료될 때까지 차단하는 동기 AuthenticateAsClient 메서드 또는 인증이 완료될 때까지 기다리는 것을 차단하지 않는 비동기 BeginAuthenticateAsClient 메서드를 사용하여 인증을 시작합니다. 서버는 동기 AuthenticateAsServer 또는 비동기 BeginAuthenticateAsServer 메서드를 사용하여 인증을 시작합니다. 클라이언트와 서버 모두 인증을 시작해야 합니다.

인증은 SSPI(보안 지원 공급자) 채널 공급자에 의해 처리됩니다. 클라이언트는 SslStream만들 때 RemoteCertificateValidationCallback 대리자를 지정하여 서버 인증서의 유효성 검사를 제어할 수 있습니다. 서버는 RemoteCertificateValidationCallback 대리자를 제공하여 유효성 검사를 제어할 수도 있습니다. 대리자가 참조하는 메서드에는 원격 당사자의 인증서 및 인증서의 유효성을 검사하는 동안 발생한 오류 SSPI가 포함됩니다. 서버에서 대리자를 지정하는 경우 서버에서 클라이언트 인증을 요청했는지 여부에 관계없이 대리자의 메서드가 호출됩니다. 서버가 클라이언트 인증을 요청하지 않은 경우 서버의 대리자 메서드는 null 인증서와 빈 인증서 오류 배열을 받습니다.

서버에 클라이언트 인증이 필요한 경우 클라이언트는 인증을 위해 하나 이상의 인증서를 지정해야 합니다. 클라이언트에 둘 이상의 인증서가 있는 경우 클라이언트는 서버에 대한 올바른 인증서를 선택하는 LocalCertificateSelectionCallback 대리자를 제공할 수 있습니다. 클라이언트의 인증서는 현재 사용자의 "내" 인증서 저장소에 있어야 합니다. 인증서를 통한 클라이언트 인증은 Ssl2(SSL 버전 2) 프로토콜에 대해 지원되지 않습니다.

인증에 실패하면 AuthenticationException받게 되며 SslStream 더 이상 사용할 수 없습니다. 가비지 수집기에서 수집할 수 있도록 이 개체를 닫고 이 개체에 대한 모든 참조를 제거해야 합니다.

SSL 핸드셰이크라고도 하는 인증 프로세스가 성공하면 서버의 ID(및 필요에 따라 클라이언트)가 설정되고 클라이언트와 서버에서 SslStream 사용하여 메시지를 교환할 수 있습니다. 정보를 보내거나 받기 전에 클라이언트와 서버는 SslStream 제공하는 보안 서비스 및 수준을 확인하여 선택한 프로토콜, 알고리즘 및 강도가 무결성 및 기밀성에 대한 요구 사항을 충족하는지 여부를 확인해야 합니다. 현재 설정이 충분하지 않으면 스트림을 닫아야 합니다. IsEncrypted 및 IsSigned 속성을 사용하여 SslStream 제공하는 보안 서비스를 확인할 수 있습니다. 다음 표에서는 인증, 암호화 및 데이터 서명에 사용되는 암호화 설정을 보고하는 요소를 보여줍니다.

요소	회원
서버 및 필요에 따라 클라이언트를 인증하는 데 사용되는 보안 프로토콜입니다.	SslProtocol 속성 및 연결된 SslProtocols 열거형입니다.
키 교환 알고리즘입니다.	KeyExchangeAlgorithm 속성 및 연결된 ExchangeAlgorithmType 열거형입니다.
메시지 무결성 알고리즘입니다.	HashAlgorithm 속성 및 연결된 HashAlgorithmType 열거형입니다.
메시지 기밀성 알고리즘입니다.	CipherAlgorithm 속성 및 연결된 CipherAlgorithmType 열거형입니다.
선택한 알고리즘의 강도입니다.	KeyExchangeStrength, HashStrength및 CipherStrength 속성입니다.

인증에 성공하면 동기 Write 또는 비동기 BeginWrite 메서드를 사용하여 데이터를 보낼 수 있습니다. 동기 Read 또는 비동기 BeginRead 메서드를 사용하여 데이터를 받을 수 있습니다.

SslStream 기본 스트림을 열어 두도록 지정한 경우 사용이 완료되면 해당 스트림을 닫아야 합니다.

메모

SslStream 개체를 만드는 애플리케이션이 일반 사용자의 자격 증명으로 실행되는 경우 사용자에게 명시적으로 권한을 부여하지 않는 한 애플리케이션은 로컬 컴퓨터 저장소에 설치된 인증서에 액세스할 수 없습니다.

SslStream 내부 스트림에서 throw될 때 다른 IOException 함께 시간 제한이 호출자에 의해 치명적인 것으로 처리된다고 가정합니다. 시간 제한 후 SslStream 인스턴스를 다시 사용하면 가비지가 반환됩니다. 애플리케이션은 SslStream Close 이러한 경우 예외를 throw해야 합니다.

.NET Framework 4.6에는 연결에 대한 안전하지 않은 암호 및 해시 알고리즘을 차단하는 새로운 보안 기능이 포함되어 있습니다. HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream 등과 같은 API를 통해 TLS/SSL을 사용하고 .NET Framework 4.6을 대상으로 하는 애플리케이션은 기본적으로 보다 안전한 동작을 가져옵니다.

개발자는 기존 SSL3 서비스 또는 RC4 서비스와의 TLS와의 상호 운용성을 유지하기 위해 이 동작을 옵트아웃할 수 있습니다. 이 문서에서는 새 동작을 사용하지 않도록 코드를 수정하는 방법을 설명합니다.

.NET Framework 4.7은 TLS 버전을 지정하지 않고 대신 SCHANNEL시스템 기본값으로 정의된 TLS 버전을 사용하는 SslStreams를 인증하는 메서드에 대한 새 오버로드를 추가합니다. 앱에서 이러한 메서드를 사용하여 나중에 앱을 다시 빌드하고 다시 배포할 필요 없이 시간이 지남에 따라 TLS 버전 모범 사례 변경으로 기본값을 수정할 수 있습니다.

또한 .NET FrameworkTLS(전송 계층 보안) 모범 사례를 참조하세요.

생성자

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	이 SslStream 데이터 암호화를 사용하는지 여부를 나타내는 Boolean 값을 가져옵니다.
IsMutuallyAuthenticated	서버와 클라이언트가 모두 인증되었는지 여부를 나타내는 Boolean 값을 가져옵니다.
IsServer	이 SslStream 사용된 연결의 로컬 쪽이 서버로 인증되었는지 여부를 나타내는 Boolean 값을 가져옵니다.
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)	스트림에서 데이터를 읽고 지정된 배열에 저장하는 비동기 읽기 작업을 시작합니다.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	비동기 읽기 작업을 시작합니다. (대신 ReadAsync(Byte[], Int32, Int32) 사용하는 것이 좋습니다.) (다음에서 상속됨 Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	지정된 버퍼에서 스트림으로 Byte쓰는 비동기 쓰기 작업을 시작합니다.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	비동기 쓰기 작업을 시작합니다. (대신 WriteAsync(Byte[], Int32, Int32) 사용하는 것이 좋습니다.) (다음에서 상속됨 Stream)
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)	원격 개체와 통신하는 데 사용되는 프록시를 생성하는 데 필요한 모든 관련 정보를 포함하는 개체를 만듭니다. (다음에서 상속됨 MarshalByRefObject)
CreateWaitHandle()	사용되지 않음. 사용되지 않음. 사용되지 않음. WaitHandle 개체를 할당합니다. (다음에서 상속됨 Stream)
Dispose()	Stream사용하는 모든 리소스를 해제합니다. (다음에서 상속됨 Stream)
Dispose(Boolean)	SslStream 사용하는 관리되지 않는 리소스를 해제하고 필요에 따라 관리되는 리소스를 해제합니다.
Dispose(Boolean)	AuthenticatedStream 사용하는 관리되지 않는 리소스를 해제하고 필요에 따라 관리되는 리소스를 해제합니다. (다음에서 상속됨 AuthenticatedStream)
DisposeAsync()	SslStream사용되는 관리되지 않는 관리되는 리소스를 비동기적으로 해제합니다.
DisposeAsync()	AuthenticatedStream사용되는 관리되지 않는 관리되는 리소스를 비동기적으로 해제합니다. (다음에서 상속됨 AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)	BeginAuthenticateAsClient대한 이전 호출로 시작된 보류 중인 비동기 서버 인증 작업을 종료합니다.
EndAuthenticateAsServer(IAsyncResult)	BeginAuthenticateAsClient대한 이전 호출로 시작된 보류 중인 비동기 클라이언트 인증 작업을 종료합니다.
EndRead(IAsyncResult)	BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)대한 이전 호출로 시작된 비동기 읽기 작업을 종료합니다.
EndRead(IAsyncResult)	보류 중인 비동기 읽기가 완료되기를 기다립니다. (대신 ReadAsync(Byte[], Int32, Int32) 사용하는 것이 좋습니다.) (다음에서 상속됨 Stream)
EndWrite(IAsyncResult)	BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)대한 이전 호출로 시작된 비동기 쓰기 작업을 종료합니다.
EndWrite(IAsyncResult)	비동기 쓰기 작업을 종료합니다. (대신 WriteAsync(Byte[], Int32, Int32) 사용하는 것이 좋습니다.) (다음에서 상속됨 Stream)
Equals(Object)	지정된 개체가 현재 개체와 같은지 여부를 확인합니다. (다음에서 상속됨 Object)
Finalize()	SslStream사용하는 모든 리소스를 해제합니다.
Flush()	버퍼링된 데이터가 기본 디바이스에 기록되도록 합니다.
FlushAsync()	이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 데이터가 기본 디바이스에 기록되도록 합니다. (다음에서 상속됨 Stream)
FlushAsync(CancellationToken)	버퍼링된 데이터를 기본 디바이스에 비동기적으로 씁니다.
FlushAsync(CancellationToken)	이 스트림에 대한 모든 버퍼를 비동기적으로 지우고, 버퍼링된 데이터를 기본 디바이스에 쓰게 하고, 취소 요청을 모니터링합니다. (다음에서 상속됨 Stream)
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(Byte[], Int32, Int32, CancellationToken)	현재 스트림에서 바이트 시퀀스를 비동기적으로 읽고, 읽은 바이트 수만큼 스트림 내의 위치를 이동하고, 취소 요청을 모니터링합니다. (다음에서 상속됨 Stream)
ReadAsync(Memory<Byte>, CancellationToken)	이 스트림에서 데이터를 비동기적으로 읽고 지정된 메모리 범위에 저장합니다.
ReadAsync(Memory<Byte>, CancellationToken)	현재 스트림에서 바이트 시퀀스를 비동기적으로 읽고, 읽은 바이트 수만큼 스트림 내의 위치를 이동하고, 취소 요청을 모니터링합니다. (다음에서 상속됨 Stream)
ReadAtLeast(Span<Byte>, Int32, Boolean)	현재 스트림에서 최소 바이트 수를 읽고 읽은 바이트 수만큼 스트림 내의 위치를 앞으로 이동합니다. (다음에서 상속됨 Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	현재 스트림에서 최소 바이트 수를 비동기적으로 읽고, 읽은 바이트 수만큼 스트림 내의 위치를 이동하고, 취소 요청을 모니터링합니다. (다음에서 상속됨 Stream)
ReadByte()	SslStream 바이트를 읽고 스트림 내의 위치를 1 바이트씩 이동하거나 스트림의 끝에 있는 경우 -1 반환합니다.
ReadByte()	스트림에서 바이트를 읽고 스트림 내의 위치를 1 바이트씩 이동하거나 스트림의 끝에 있는 경우 -1 반환합니다. (다음에서 상속됨 Stream)
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)	NotSupportedExceptionthrow합니다.
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(Byte[], Int32, Int32, CancellationToken)	바이트 시퀀스를 현재 스트림에 비동기적으로 쓰고, 기록된 바이트 수만큼 이 스트림 내의 현재 위치를 발전시키고, 취소 요청을 모니터링합니다. (다음에서 상속됨 Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	읽기 전용 바이트 메모리 범위에서 기본 스트림에 데이터를 비동기적으로 씁니다.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	바이트 시퀀스를 현재 스트림에 비동기적으로 쓰고, 기록된 바이트 수만큼 이 스트림 내의 현재 위치를 발전시키고, 취소 요청을 모니터링합니다. (다음에서 상속됨 Stream)
WriteByte(Byte)	스트림의 현재 위치에 바이트를 쓰고 스트림 내의 위치를 1 바이트씩 진행합니다. (다음에서 상속됨 Stream)

확장 메서드

CopyToAsync(Stream, PipeWriter, CancellationToken)	취소 토큰을 사용하여 Stream 바이트를 비동기적으로 읽고 지정된 PipeWriter씁니다.
ConfigureAwait(IAsyncDisposable, Boolean)	비동기 삭제 가능 파일에서 반환된 작업에 대한 대기가 수행되는 방법을 구성합니다.

적용 대상

다음을 통해 공유

SslStream 클래스

정의

예제

설명

생성자

속성

메서드

확장 메서드

적용 대상

추가 정보

추가 리소스