SslStream 클래스

정의

SSL(Secure Socket Layer) 보안 프로토콜을 사용하여 서버 및 필요에 따라 클라이언트를 인증하는 클라이언트-서버 통신에 사용되는 스트림을 제공합니다.Provides a stream used for client-server communication that uses the Secure Socket Layer (SSL) security protocol to authenticate the server and optionally the client.

public ref class SslStream : System::Net::Security::AuthenticatedStream
public class SslStream : System.Net.Security.AuthenticatedStream
type SslStream = class
    inherit AuthenticatedStream
    interface IDisposable
Public Class SslStream
Inherits AuthenticatedStream
상속
구현

예제

다음 코드 예제에서는 SslStream 클래스를 사용 하 여 클라이언트와 통신 하는 TcpListener을 만드는 방법을 보여 줍니다.The following code example demonstrates creating an TcpListener that uses the SslStream class to communicate with clients.

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


   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, 8080);    
            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);
         }
         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, 8080)
            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)
        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을 만드는 방법을 보여 줍니다.The following code example demonstrates creating a TcpClient that uses the SslStream class to communicate with a server.

#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, 8080);
            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,443);
            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, 443)
            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를 사용 하 여 전송 된 메시지에 대 한 기밀성 및 무결성 검사를 제공 합니다.SSL protocols help to provide confidentiality and integrity checking for messages transmitted using an SslStream. SslStream에서 제공 하는 것과 같은 SSL 연결은 클라이언트와 서버 간에 중요 한 정보를 전달할 때 사용 해야 합니다.An SSL connection, such as that provided by SslStream, should be used when communicating sensitive information between a client and a server. SslStream를 사용 하면 네트워크에서 전송 되는 동안 정보를 읽고 변조 하는 것을 방지할 수 있습니다.Using an SslStream helps to prevent anyone from reading and tampering with information while it is in transit on the network.

SslStream 인스턴스는 SslStream을 만들 때 제공 하는 스트림을 사용 하 여 데이터를 전송 합니다.An SslStream instance transmits data using a stream that you supply when creating the SslStream. 이 기본 스트림을 제공 하면 SslStream를 닫을 때 내부 스트림도 닫을지 여부를 지정 하는 옵션이 제공 됩니다.When you supply this underlying stream, you have the option to specify whether closing the SslStream also closes the underlying stream. 일반적으로 SslStream 클래스는 TcpClientTcpListener 클래스와 함께 사용 됩니다.Typically, the SslStream class is used with the TcpClient and TcpListener classes. GetStream 메서드는 SslStream 클래스와 함께 사용 하기에 적합 한 NetworkStream를 제공 합니다.The GetStream method provides a NetworkStream suitable for use with the SslStream class.

SslStream서버를 만든 후 필요에 따라 클라이언트를 인증 해야 합니다.After creating an SslStream, the server and optionally, the client must be authenticated. 서버에서 X509를 제공 해야 인증서 id를 증명 하는 클라이언트 에서도 수행할 요청할 수 있습니다.The server must provide an X509 certificate that establishes proof of its identity and can request that the client also do so. SslStream를 사용 하 여 정보를 전송 하기 전에 인증을 수행 해야 합니다.Authentication must be performed before transmitting information using an SslStream. 클라이언트는 인증이 완료 될 때까지 차단 되는 동기 AuthenticateAsClient 메서드 또는 인증 완료 대기를 차단 하지 않는 비동기 BeginAuthenticateAsClient 메서드를 사용 하 여 인증을 시작 합니다.Clients initiate authentication using the synchronous AuthenticateAsClient methods, which block until the authentication completes, or the asynchronous BeginAuthenticateAsClient methods, which do not block waiting for the authentication to complete. 서버는 동기 AuthenticateAsServer 또는 비동기 BeginAuthenticateAsServer 메서드를 사용 하 여 인증을 시작 합니다.Servers initiate authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. 클라이언트 및 서버 인증을 시작 해야 합니다.Both client and server must initiate the authentication.

인증 보안 지원 공급자 (SSPI) 채널 공급자에 의해 처리 됩니다.The authentication is handled by the Security Support Provider (SSPI) channel provider. 클라이언트에는 SslStream를 만들 때 RemoteCertificateValidationCallback 대리자를 지정 하 여 서버 인증서의 유효성 검사를 제어할 수 있는 기회가 제공 됩니다.The client is given an opportunity to control validation of the server's certificate by specifying a RemoteCertificateValidationCallback delegate when creating an SslStream. 서버는 RemoteCertificateValidationCallback 대리자를 제공 하 여 유효성 검사를 제어할 수도 있습니다.The server can also control validation by supplying a RemoteCertificateValidationCallback delegate. 대리자가 참조 하는 메서드는 원격 상대방의 인증서 및 인증서의 유효성을 검사 하는 동안 발생 하는 SSPI 오류를 포함 합니다.The method referenced by the delegate includes the remote party's certificate and any errors SSPI encountered while validating the certificate. 서버에서 대리자를 지정 하는 경우 서버에서 클라이언트 인증을 요청 하는 여부에 관계 없이 대리자의 메서드가 호출 되는 참고 합니다.Note that if the server specifies a delegate, the delegate's method is invoked regardless of whether the server requested client authentication. 서버에서 클라이언트 인증, 요청 되지 않은 경우 서버의 대리자 메서드는 null 인증서 및 인증서 오류의 빈 배열을 받습니다.If the server did not request client authentication, the server's delegate method receives a null certificate and an empty array of certificate errors.

서버에 클라이언트 인증이 필요한 경우 클라이언트 인증에 대 한 하나 이상의 인증서를 지정 해야 합니다.If the server requires client authentication, the client must specify one or more certificates for authentication. 클라이언트에 두 개 이상의 인증서가 있는 경우 클라이언트는 서버에 대 한 올바른 인증서를 선택 하는 LocalCertificateSelectionCallback 대리자를 제공할 수 있습니다.If the client has more than one certificate, the client can provide a LocalCertificateSelectionCallback delegate to select the correct certificate for the server. 클라이언트의 인증서는 현재 사용자의 "My" 인증서 저장소에 있어야 합니다.The client's certificates must be located in the current user's "My" certificate store. 인증서를 통한 클라이언트 인증은 Ssl2 (SSL 버전 2) 프로토콜에 대해 지원 되지 않습니다.Client authentication via certificates is not supported for the Ssl2 (SSL version 2) protocol.

인증에 실패 하면 AuthenticationException수신 되 고 SslStream 더 이상 사용할 수 없습니다.If the authentication fails, you receive a AuthenticationException, and the SslStream is no longer useable. 이 개체를 닫기 및 가비지 수집기에서 수집할 수 있도록 모든 참조가 제거 됩니다.You should close this object and remove all references to it so that it can be collected by the garbage collector.

SSL 핸드셰이크 라고도 하는 인증 프로세스가 성공 하면 서버 id (필요에 따라 클라이언트)가 설정 되 고 SslStream 클라이언트와 서버에서 메시지를 교환 하는 데 사용할 수 있습니다.When the authentication process, also known as the SSL handshake, succeeds, the identity of the server (and optionally, the client) is established and the SslStream can be used by the client and server to exchange messages. 클라이언트와 서버는 정보를 보내거나 받기 전에 SslStream에서 제공 하는 보안 서비스와 수준을 확인 하 여 선택한 프로토콜, 알고리즘 및 강도가 무결성 및 기밀성 요구 사항을 충족 하는지 여부를 확인 해야 합니다.Before sending or receiving information, the client and server should check the security services and levels provided by the SslStream to determine whether the protocol, algorithms, and strengths selected meet their requirements for integrity and confidentiality. 현재 설정을 충분 하지 않으면, 스트림을 닫아야 합니다.If the current settings are not sufficient, the stream should be closed. IsEncryptedIsSigned 속성을 사용 하 여 SslStream에서 제공 하는 보안 서비스를 확인할 수 있습니다.You can check the security services provided by the SslStream using the IsEncrypted and IsSigned properties. 다음 표에서 인증, 암호화 및 서명 하는 데이터에 사용 되는 암호화 설정을 보고 하는 요소를 보여 줍니다.The following table shows the elements that report the cryptographic settings used for authentication, encryption and data signing.

요소Element 멤버Members
서버 및 필요에 따라 클라이언트를 인증 하는 데 사용 하는 보안 프로토콜입니다.The security protocol used to authenticate the server and, optionally, the client. SslProtocol 속성 및 연결 된 SslProtocols 열거형입니다.The SslProtocol property and the associated SslProtocols enumeration.
키 교환 알고리즘입니다.The key exchange algorithm. KeyExchangeAlgorithm 속성 및 연결 된 ExchangeAlgorithmType 열거형입니다.The KeyExchangeAlgorithm property and the associated ExchangeAlgorithmType enumeration.
메시지 무결성 알고리즘입니다.The message integrity algorithm. HashAlgorithm 속성 및 연결 된 HashAlgorithmType 열거형입니다.The HashAlgorithm property and the associated HashAlgorithmType enumeration.
메시지 기밀성 알고리즘입니다.The message confidentiality algorithm. CipherAlgorithm 속성 및 연결 된 CipherAlgorithmType 열거형입니다.The CipherAlgorithm property and the associated CipherAlgorithmType enumeration.
선택한 알고리즘의 장점입니다.The strengths of the selected algorithms. KeyExchangeStrength, HashStrengthCipherStrength 속성입니다.The KeyExchangeStrength, HashStrength, and CipherStrength properties.

인증에 성공 하면 동기 Write 또는 비동기 BeginWrite 메서드를 사용 하 여 데이터를 보낼 수 있습니다.After a successful authentication, you can send data using the synchronous Write or asynchronous BeginWrite methods. 동기 Read 또는 비동기 BeginRead 메서드를 사용 하 여 데이터를 받을 수 있습니다.You can receive data using the synchronous Read or asynchronous BeginRead methods.

기본 스트림을 열어 두어야 하는 SslStream 지정 하는 경우 사용을 마치면 해당 스트림을 닫을 책임이 있습니다.If you specified to the SslStream that the underlying stream should be left open, you are responsible for closing that stream when you are done using it.

참고

만들고 있는 애플리케이션을 SslStream 일반 사용자의 자격 증명을 사용 하 여 실행 개체, 애플리케이션 권한을 명시적으로 부여 되어 사용자에 게 이렇게 하려면 로컬 컴퓨터 저장소에 설치 된 인증서에 액세스할 수 없습니다.If the application that creates the SslStream object runs with the credentials of a Normal user, the application will not be able to access certificates installed in the local machine store unless permission has been explicitly given to the user to do so.

SslStream는 내부 스트림에서 throw 되는 다른 IOException와 함께 시간 제한이 호출자에 의해 심각 하 게 처리 되는 것으로 가정 합니다.SslStream assumes that a timeout along with any other IOException when one is thrown from the inner stream will be treated as fatal by its caller. 제한 시간 후에 SslStream 인스턴스를 다시 사용 하면 가비지가 반환 됩니다.Reusing a SslStream instance after a timeout will return garbage. 애플리케이션 해야 CloseSslStream 이러한 경우 예외를 throw 합니다.An application should Close the SslStream and throw an exception in these cases.

.NET Framework 4.6에는 안전 하지 않은 암호화 및 해시 알고리즘에 대 한 연결을 차단 하는 새로운 보안 기능이 포함 됩니다.The .NET Framework 4.6 includes a new security feature that blocks insecure cipher and hashing algorithms for connections. 응용 프로그램 및 HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream 등 Api 통해 TLS/SSL을 사용 하 여.NET Framework 4.6을 대상으로 하는 기본적으로는 더 안전한 동작을 가져옵니다.Applications using TLS/SSL through APIs such as HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream, etc. and targeting .NET Framework 4.6 get the more-secure behavior by default.

개발자는 RC4 서비스를 지 원하는 기존 SSL3 서비스 또는 TLS와의 상호 운용성을 유지 하기 위해이 동작을 옵트아웃 하려면 원할 수 있습니다.Developers may want to opt out of this behavior in order to maintain interoperability with their existing SSL3 services OR TLS w/ RC4 services. 이 문서 에서는 새 동작을 사용 하지 않도록 코드를 수정 하는 방법을 설명 합니다.This article explains how to modify your code so that the new behavior is disabled.

.NET Framework 4.7는 TLS 버전을 지정 하지 않는 SslStreams을 인증 하는 메서드에 대 한 새 오버 로드를 추가 하지만, 대신 SCHANNEL의 시스템 기본값으로 정의 된 tls 버전을 사용 합니다.The .NET Framework 4.7 adds new overloads for the methods that authenticate SslStreams that do not specify a TLS version, but instead use the TLS version defined as the system default in SCHANNEL. 앱에서 이러한 메서드를 사용 하 여 나중에 TLS 버전 모범 사례 변경 내용을 시간이 지남에 따라 기본값을 수정 하려면 수 하는 방법으로 다시 작성 하 고 앱을 다시 배포 하지 않고도 합니다.Use these methods in your app as a way to be able to later modify the defaults as TLS version best practice changes over time, without the need to rebuild and redeploy your app.

또한 .NET Framework 사용 하는 TLS (전송 계층 보안) 모범 사례를 참조 하세요.Also see Transport Layer Security (TLS) best practices with the .NET Framework.

생성자

SslStream(Stream)

지정된 SslStream를 사용하여 Stream 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the SslStream class using the specified Stream.

SslStream(Stream, Boolean)

지정된 SslStream과 스트림 닫기 동작을 사용해서 Stream 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the SslStream class using the specified Stream and stream closure behavior.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback)

지정된 SslStream, 스트림 닫기 동작 및 인증서 유효성 검사 대리자를 사용하여 Stream 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the SslStream class using the specified Stream, stream closure behavior and certificate validation delegate.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)

지정된 SslStream, 스트림 닫기 동작, 인증서 유효성 검사 대리자 및 인증서 선택 대리자를 사용하여 Stream 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the SslStream class using the specified Stream, stream closure behavior, certificate validation delegate and certificate selection delegate.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)

지정된 SslStream을 사용하여 Stream 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the SslStream class using the specified Stream

속성

CanRead

기본 스트림을 읽을 수 있는지를 나타내는 Boolean 값을 가져옵니다.Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek

기본 스트림을 검색할 수 있는지를 나타내는 Boolean 값을 가져옵니다.Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout

기본 스트림에 제한 시간을 설정할 수 있는지를 나타내는 Boolean 값을 가져옵니다.Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite

기본 스트림이 쓰기 가능한지를 나타내는 Boolean 값을 가져옵니다.Gets a Boolean value that indicates whether the underlying stream is writable.

CheckCertRevocationStatus

인증서 유효성 검사 프로세스를 진행하는 동안 인증서 해지 목록을 확인하는지 여부를 나타내는 Boolean 값을 가져옵니다.Gets a Boolean value that indicates whether the certificate revocation list is checked during the certificate validation process.

CipherAlgorithm

SslStream에서 사용하는 일괄 암호화 알고리즘을 식별하는 값을 가져옵니다.Gets a value that identifies the bulk encryption algorithm used by this SslStream.

CipherStrength

SslStream에서 사용하는 암호화 알고리즘의 강도를 식별하는 값을 가져옵니다.Gets a value that identifies the strength of the cipher algorithm used by this SslStream.

HashAlgorithm

MAC(메시지 인증 코드)를 생성하는 데 사용되는 알고리즘을 가져옵니다.Gets the algorithm used for generating message authentication codes (MACs).

HashStrength

이 인스턴스에서 사용하는 해시 알고리즘의 강도를 식별하는 값을 가져옵니다.Gets a value that identifies the strength of the hash algorithm used by this instance.

InnerStream

AuthenticatedStream에서 데이터를 보내고 받는 데 사용하는 스트림을 가져옵니다.Gets the stream used by this AuthenticatedStream for sending and receiving data.

(다음에서 상속됨 AuthenticatedStream)
IsAuthenticated

인증이 성공했는지를 나타내는 Boolean 값을 가져옵니다.Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted

SslStream에서 데이터 암호화를 사용하는지 여부를 나타내는 Boolean 값을 가져옵니다.Gets a Boolean value that indicates whether this SslStream uses data encryption.

IsMutuallyAuthenticated

서버와 클라이언트 모두 인증되었는지 여부를 나타내는 Boolean 값을 가져옵니다.Gets a Boolean value that indicates whether both server and client have been authenticated.

IsServer

SslStream에서 사용하는 연결의 로컬측이 서버로 인증되었는지 여부를 나타내는 Boolean 값을 가져옵니다.Gets a Boolean value that indicates whether the local side of the connection used by this SslStream was authenticated as the server.

IsSigned

이 스트림을 사용하여 보내는 데이터에 서명할지를 나타내는 Boolean 값을 가져옵니다.Gets a Boolean value that indicates whether the data sent using this stream is signed.

KeyExchangeAlgorithm

SslStream에서 사용하는 키 교환 알고리즘을 가져옵니다.Gets the key exchange algorithm used by this SslStream.

KeyExchangeStrength

이 인스턴스에서 사용하는 키 교환 알고리즘의 강도를 식별하는 값을 가져옵니다.Gets a value that identifies the strength of the key exchange algorithm used by this instance.

LeaveInnerStreamOpen

AuthenticatedStream에서 데이터를 보내고 받는 데 사용하는 스트림이 계속 열려 있는지 여부를 가져옵니다.Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(다음에서 상속됨 AuthenticatedStream)
Length

기본 스트림의 길이를 가져옵니다.Gets the length of the underlying stream.

LocalCertificate

로컬 엔드포인트를 인증하는 데 사용되는 인증서를 가져옵니다.Gets the certificate used to authenticate the local endpoint.

NegotiatedApplicationProtocol
NegotiatedCipherSuite

이 연결용으로 협상된 암호 그룹을 가져옵니다.Gets the cipher suite which was negotiated for this connection.

Position

기본 스트림 내의 현재 위치를 가져오거나 설정합니다.Gets or sets the current position in the underlying stream.

ReadTimeout

읽기 작업에서 데이터 대기를 차단하는 시간(밀리초)을 가져오거나 설정합니다.Gets or sets the amount of time, expressed in milliseconds, a read operation blocks waiting for data.

RemoteCertificate

원격 엔드포인트를 인증하는 데 사용되는 인증서를 가져옵니다.Gets the certificate used to authenticate the remote endpoint.

SslProtocol

이 연결을 인증하는 데 사용된 보안 프로토콜을 나타내는 값을 가져옵니다.Gets a value that indicates the security protocol used to authenticate this connection.

TransportContext

확장 보호를 사용하는 인증에 사용되는 TransportContext를 가져옵니다.Gets the TransportContext used for authentication using extended protection.

WriteTimeout

쓰기 작업에서 데이터 대기를 차단하는 시간을 가져오거나 설정합니다.Gets or sets the amount of time a write operation blocks waiting for data.

메서드

AuthenticateAsClient(String)

클라이언트-서버 연결에서 서버 및 필요에 따라 클라이언트를 인증하기 위해 클라이언트에서 호출됩니다.Called by clients to authenticate the server and optionally the client in a client-server connection.

AuthenticateAsClient(String, X509CertificateCollection, Boolean)

클라이언트-서버 연결에서 서버 및 필요에 따라 클라이언트를 인증하기 위해 클라이언트에서 호출됩니다.Called by clients to authenticate the server and optionally the client in a client-server connection. 인증 프로세스에서는 지정된 인증서 컬렉션과 시스템 기본 SSL 프로토콜을 사용합니다.The authentication process uses the specified certificate collection, and the system default SSL protocol.

AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)

클라이언트-서버 연결에서 서버 및 필요에 따라 클라이언트를 인증하기 위해 클라이언트에서 호출됩니다.Called by clients to authenticate the server and optionally the client in a client-server connection. 인증 프로세스에는 지정된 인증서 컬렉션과 SSL 프로토콜이 사용됩니다.The authentication process uses the specified certificate collection and SSL protocol.

AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)
AuthenticateAsClientAsync(String)

클라이언트-서버 연결에서 비동기 작업으로 서버 및 필요에 따라 클라이언트를 인증하기 위해 클라이언트에서 호출됩니다.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)

클라이언트-서버 연결에서 비동기 작업으로 서버 및 필요에 따라 클라이언트를 인증하기 위해 클라이언트에서 호출됩니다.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. 인증 프로세스에서는 지정된 인증서 컬렉션과 시스템 기본 SSL 프로토콜을 사용합니다.The authentication process uses the specified certificate collection and the system default SSL protocol.

AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)

클라이언트-서버 연결에서 비동기 작업으로 서버 및 필요에 따라 클라이언트를 인증하기 위해 클라이언트에서 호출됩니다.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. 인증 프로세스에는 지정된 인증서 컬렉션과 SSL 프로토콜이 사용됩니다.The authentication process uses the specified certificate collection and SSL protocol.

AuthenticateAsServer(X509Certificate)

클라이언트-서버 연결에서 지정된 인증서를 사용하여 서버를 인증하고 선택적으로 클라이언트를 인증하기 위해 서버에서 호출합니다.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificate.

AuthenticateAsServer(X509Certificate, Boolean, Boolean)

지정된 인증서, 요구 사항 및 시스템 기본 보안 프로토콜을 사용하여 클라이언트-서버 연결에서 서버 및 필요에 따라 클라이언트를 인증하기 위해 서버에서 호출됩니다.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates and requirements, and using the system default security protocol.

AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)

지정된 인증서, 요구 사항 및 보안 프로토콜을 사용하여 클라이언트-서버 연결에서 서버 및 필요에 따라 클라이언트를 인증하기 위해 서버에서 호출됩니다.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates, requirements and security protocol.

AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)
AuthenticateAsServerAsync(X509Certificate)

클라이언트-서버 연결에서 지정된 인증서를 사용하여 서버를 인증하고 선택적으로 클라이언트를 인증하기 위해 비동기 작업으로 서버에서 호출합니다.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificate as an asynchronous operation.

AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)

지정된 인증서, 요구 사항 및 보안 프로토콜을 사용하여 클라이언트-서버 연결에서 서버 및 필요에 따라 클라이언트를 비동기 작업으로 인증하기 위해 서버에서 호출됩니다.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates, requirements and security protocol as an asynchronous operation.

AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)

지정된 인증서, 요구 사항 및 보안 프로토콜을 사용하여 클라이언트-서버 연결에서 서버 및 필요에 따라 클라이언트를 비동기 작업으로 인증하기 위해 서버에서 호출됩니다.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates, requirements and security protocol as an asynchronous operation.

BeginAuthenticateAsClient(String, AsyncCallback, Object)

서버를 인증하고 선택적으로 클라이언트를 인증하는 비동기 작업을 시작하기 위해 클라이언트에서 호출합니다.Called by clients to begin an asynchronous operation to authenticate the server and optionally the client.

BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)

지정된 인증서 및 시스템 기본 보안 프로토콜을 사용하여 서버 및 필요에 따라 클라이언트를 인증하는 비동기 작업을 시작하기 위해 클라이언트에서 호출됩니다.Called by clients to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates and the system default security protocol.

BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)

지정된 인증서 및 보안 프로토콜을 사용하여 서버를 인증하고 선택적으로 클라이언트를 인증하는 비동기 작업을 시작하기 위해 클라이언트에서 호출합니다.Called by clients to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates and security protocol.

BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)

클라이언트-서버 연결에서 클라이언트를 인증하고 선택적으로 서버를 인증하는 비동기 작업을 시작하기 위해 서버에서 호출합니다.Called by servers to begin an asynchronous operation to authenticate the client and optionally the server in a client-server connection.

BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)

지정된 인증서, 요구 사항 및 시스템 기본 보안 프로토콜을 사용하여 서버 및 필요에 따라 클라이언트를 인증하는 비동기 작업을 시작하기 위해 서버에서 호출됩니다.Called by servers to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates and requirements, and the system default security protocol.

BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)

지정된 인증서, 요구 사항 및 보안 프로토콜을 사용하여 서버 및 필요에 따라 클라이언트를 인증하는 비동기 작업을 시작하기 위해 서버에서 호출됩니다.Called by servers to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates, requirements and security protocol.

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

스트림에서 데이터를 읽어 지정된 배열에 저장하는 비동기 읽기 작업을 시작합니다.Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

지정된 버퍼에서 스트림에 Byte를 쓰는 비동기 쓰기 작업을 시작합니다.Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

Close()

현재 스트림을 닫고 현재 스트림과 관련된 소켓과 파일 핸들 등의 리소스를 모두 해제합니다.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. 이 메서드를 호출하는 대신 스트림이 올바르게 삭제되었는지 확인합니다.Instead of calling this method, ensure that the stream is properly disposed.

(다음에서 상속됨 Stream)
CopyTo(Stream)

현재 스트림에서 바이트를 읽어서 다른 스트림에 해당 바이트를 씁니다.Reads the bytes from the current stream and writes them to another stream.

(다음에서 상속됨 Stream)
CopyTo(Stream, Int32)

현재 스트림에서 바이트를 읽어서 지정된 버퍼 크기로 다른 스트림에 씁니다.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(다음에서 상속됨 Stream)
CopyToAsync(Stream)

현재 스트림에서 모든 바이트를 비동기적으로 읽어 다른 스트림에 씁니다.Asynchronously reads the bytes from the current stream and writes them to another stream.

(다음에서 상속됨 Stream)
CopyToAsync(Stream, CancellationToken)

현재 스트림에서 바이트를 비동기적으로 읽어 지정된 취소 토큰을 사용하여 다른 스트림에 씁니다.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(다음에서 상속됨 Stream)
CopyToAsync(Stream, Int32)

현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기로 다른 스트림에 씁니다.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(다음에서 상속됨 Stream)
CopyToAsync(Stream, Int32, CancellationToken)

현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(다음에서 상속됨 Stream)
CreateObjRef(Type)

원격 개체와 통신하는 데 사용되는 프록시 생성에 필요한 모든 관련 정보가 들어 있는 개체를 만듭니다.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(다음에서 상속됨 MarshalByRefObject)
CreateWaitHandle()

WaitHandle 개체를 할당합니다.Allocates a WaitHandle object.

(다음에서 상속됨 Stream)
Dispose()

Stream에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the Stream.

(다음에서 상속됨 Stream)
Dispose(Boolean)

SslStream에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다.Releases the unmanaged resources used by the SslStream and optionally releases the managed resources.

DisposeAsync()

SslStream에서 사용하는 비관리형 리소스와 관리형 리소스를 비동기적으로 해제합니다.Asynchronously releases the unmanaged and managed resources used by the SslStream.

EndAuthenticateAsClient(IAsyncResult)

이전에 BeginAuthenticateAsClient를 호출하여 시작한 보류 상태의 비동기 서버 인증 작업을 끝냅니다.Ends a pending asynchronous server authentication operation started with a previous call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

이전에 BeginAuthenticateAsClient를 호출하여 시작한 보류 상태의 비동기 클라이언트 인증 작업을 끝냅니다.Ends a pending asynchronous client authentication operation started with a previous call to BeginAuthenticateAsClient.

EndRead(IAsyncResult)

이전에 BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)를 호출하여 시작한 비동기 읽기 작업을 끝냅니다.Ends an asynchronous read operation started with a previous call to BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).

EndWrite(IAsyncResult)

이전에 BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)를 호출하여 시작한 비동기 쓰기 작업을 끝냅니다.Ends an asynchronous write operation started with a previous call to BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).

Equals(Object)

지정한 개체가 현재 개체와 같은지를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
Flush()

버퍼링된 모든 데이터를 기본 디바이스에 씁니다.Causes any buffered data to be written to the underlying device.

FlushAsync()

이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 디바이스에 비동기적으로 쓰여지도록 합니다.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(다음에서 상속됨 Stream)
FlushAsync(CancellationToken)
GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetLifetimeService()

이 인스턴스의 수명 정책을 제어하는 현재의 수명 서비스 개체를 검색합니다.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(다음에서 상속됨 MarshalByRefObject)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
InitializeLifetimeService()

이 인스턴스의 수명 정책을 제어하는 수명 서비스 개체를 가져옵니다.Obtains a lifetime service object to control the lifetime policy for this instance.

(다음에서 상속됨 MarshalByRefObject)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
MemberwiseClone(Boolean)

현재 MarshalByRefObject 개체의 단순 복사본을 만듭니다.Creates a shallow copy of the current MarshalByRefObject object.

(다음에서 상속됨 MarshalByRefObject)
ObjectInvariant()

Contract에 대한 지원을 제공합니다.Provides support for a Contract.

(다음에서 상속됨 Stream)
Read(Byte[], Int32, Int32)

이 스트림에서 데이터를 읽어 지정된 배열에 저장합니다.Reads data from this stream and stores it in the specified array.

Read(Span<Byte>)

파생 클래스에서 재정의되면 현재 스트림에서 바이트의 시퀀스를 읽고, 읽은 바이트 수만큼 스트림 내에서 앞으로 이동합니다.When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(다음에서 상속됨 Stream)
ReadAsync(Byte[], Int32, Int32)

현재 스트림에서 바이트 시퀀스를 읽고 읽은 바이트 수만큼 스트림에서 위치를 비동기적으로 앞으로 이동합니다.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(다음에서 상속됨 Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

이 스트림에서 데이터를 비동기식으로 읽어 지정된 바이트 배열의 범위에 저장합니다.Asynchronously reads data from this stream and stores it in the specified range of a byte array.

ReadAsync(Memory<Byte>, CancellationToken)

이 스트림에서 데이터를 비동기식으로 읽어 지정된 메모리 범위에 저장합니다.Asynchronously reads data from this stream and stores it in the specified memory range.

ReadByte()

SslStream에서 바이트를 읽고 스트림 내 위치를 한 바이트씩 앞으로 이동하거나 스트림 끝일 경우 -1을 반환합니다.Reads a byte from the SslStream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

Seek(Int64, SeekOrigin)

NotSupportedException를 throw합니다.Throws a NotSupportedException.

SetLength(Int64)

기본 스트림의 길이를 설정합니다.Sets the length of the underlying stream.

ShutdownAsync()

이 SslStream을 종료합니다.Shuts down this SslStream.

ToString()

현재 개체를 나타내는 string을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)
Write(Byte[])

지정된 데이터를 이 스트림에 씁니다.Writes the specified data to this stream.

Write(Byte[], Int32, Int32)

지정된 버퍼와 오프셋을 사용하여 지정된 수의 Byte를 기본 스트림에 씁니다.Write the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>)

파생 클래스를 재정의될 때 현재 스트림에 바이트의 시퀀스를 쓰고 쓰여진 바이트 수만큼 이 스트림 내에서 앞으로 이동합니다.When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(다음에서 상속됨 Stream)
WriteAsync(Byte[], Int32, Int32)

현재 스트림에 바이트 시퀀스를 비동기적으로 쓰고 쓴 바이트 수만큼 이 스트림에서 현재 위치를 앞으로 이동합니다.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(다음에서 상속됨 Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

바이트 배열의 지정된 범위에서 데이터를 기본 스트림에 비동기식으로 씁니다.Asynchronously writes data to the underlying stream from the specified range of a byte array.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

읽기 전용 바이트 메모리 범위에서 기본 스트림에 데이터를 비동기식으로 씁니다.Asynchronously writes data to the underlying stream from a read-only byte memory range.

WriteByte(Byte)

스트림의 현재 위치에 바이트를 쓰고 스트림 내 위치를 1바이트씩 앞으로 이동합니다.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(다음에서 상속됨 Stream)

명시적 인터페이스 구현

IDisposable.Dispose()

Stream에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the Stream.

(다음에서 상속됨 Stream)

적용 대상

추가 정보