SslStream SslStream SslStream SslStream Class

定義

Secure Socket Layer (SSL) セキュリティ プロトコルを使用し、サーバーと、オプションでクライアントを認証するクライアント サーバー通信に使用されるストリームを提供します。 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
継承

作成する次のコード例に示します、TcpListenerを使用して、SslStreamクライアントと通信するクラス。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;
        } 
    }
}

作成する次のコード例に示します、TcpClientを使用して、SslStreamサーバーと通信するクラス。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;
        }
    }
}
    

注釈

SSL プロトコルは、機密性と整合性チェックを使用して送信されるメッセージを提供するのに役立ちます、SslStreamします。SSL protocols help to provide confidentiality and integrity checking for messages transmitted using an SslStream. によって提供される SSL 接続をSslStream、通信するクライアントとサーバー間で機密情報をする場合に使用する必要があります。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メソッドを提供、NetworkStreamで使用するために適した、SslStreamクラス。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. クライアントに指定することで、サーバーの証明書の検証を制御する機会を与えるが、RemoteCertificateValidationCallbackデリゲートを作成するとき、SslStreamします。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.

サーバーは、クライアント認証を必要とする場合、クライアントは、認証用の 1 つまたは複数の証明書を指定する必要があります。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 (バージョン 2 を SSL) プロトコル。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.

サーバー (および必要に応じて、クライアント) の id が確立されている、SSL ハンドシェイクとも呼ばれる、認証プロセスが成功すると、および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. によって提供されるセキュリティ サービスを確認することができます、SslStreamを使用して、IsEncryptedIsSignedプロパティ。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. KeyExchangeStrengthHashStrength、およびCipherStrengthプロパティ。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 前提と他のタイムアウト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このような場合に例外をスローします。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 SslStreams TLS のバージョンを指定しないが、システムの既定値として定義されている TLS のバージョンを使用する認証メソッドの新しいオーバー ロードを追加しますSCHANNELします。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.

参照してくださいトランスポート層セキュリティ (TLS) のベスト プラクティスは、.NET Framework でします。Also see Transport Layer Security (TLS) best practices with the .NET Framework.

コンストラクター

SslStream(Stream) SslStream(Stream) SslStream(Stream) SslStream(Stream)

SslStream を指定して Stream クラスの新しいインスタンスを初期化します。 Initializes a new instance of the SslStream class using the specified Stream.

SslStream(Stream, Boolean) SslStream(Stream, Boolean) SslStream(Stream, Boolean) SslStream(Stream, Boolean)

指定した Stream とストリームを閉じる動作を使用して、SslStream クラスの新しいインスタンスを初期化します。 Initializes a new instance of the SslStream class using the specified Stream and stream closure behavior.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback) SslStream(Stream, Boolean, RemoteCertificateValidationCallback) SslStream(Stream, Boolean, RemoteCertificateValidationCallback) SslStream(Stream, Boolean, RemoteCertificateValidationCallback)

指定した Stream、ストリームを閉じる動作、および証明書検証デリゲートを使用して、SslStream クラスの新しいインスタンスを初期化します。 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, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback) SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback) SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)

指定した Stream、ストリームを閉じる動作、証明書検証デリゲート、および証明書選択デリゲートを使用して、SslStream クラスの新しいインスタンスを初期化します。 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, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy) SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy) SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)

指定した Stream を使用して、SslStream クラスの新しいインスタンスを初期化します。 Initializes a new instance of the SslStream class using the specified Stream

プロパティ

CanRead CanRead CanRead CanRead

基になるストリームが読み取り可能かどうかを示す Boolean 値を取得します。 Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek CanSeek CanSeek CanSeek

基になるストリームがシークできるかどうかを示す Boolean 値を取得します。 Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout CanTimeout CanTimeout CanTimeout

基になるストリームがタイムアウトをサポートしているかどうかを示す Boolean 値を取得します。 Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite CanWrite CanWrite CanWrite

基になるストリームが書き込み可能かどうかを示す Boolean 値を取得します。 Gets a Boolean value that indicates whether the underlying stream is writable.

CheckCertRevocationStatus CheckCertRevocationStatus CheckCertRevocationStatus CheckCertRevocationStatus

証明書検証プロセスで、証明書失効リストを照合するかどうかを示す Boolean 値を取得します。 Gets a Boolean value that indicates whether the certificate revocation list is checked during the certificate validation process.

CipherAlgorithm CipherAlgorithm CipherAlgorithm CipherAlgorithm

この SslStream が使用する一括暗号化アルゴリズムを識別する値を取得します。 Gets a value that identifies the bulk encryption algorithm used by this SslStream.

CipherStrength CipherStrength CipherStrength CipherStrength

この SslStream が使用する暗号アルゴリズムの強度を識別する値を取得します。 Gets a value that identifies the strength of the cipher algorithm used by this SslStream.

HashAlgorithm HashAlgorithm HashAlgorithm HashAlgorithm

メッセージ認証コード (MAC: Message Authentication Code) の生成に使用するアルゴリズムを取得します。 Gets the algorithm used for generating message authentication codes (MACs).

HashStrength HashStrength HashStrength HashStrength

このインスタンスが使用するハッシュ アルゴリズムの強度を識別する値を取得します。 Gets a value that identifies the strength of the hash algorithm used by this instance.

InnerStream InnerStream InnerStream InnerStream

この AuthenticatedStream がデータの送受信に使用するストリームを取得します。 Gets the stream used by this AuthenticatedStream for sending and receiving data.

(Inherited from AuthenticatedStream)
IsAuthenticated IsAuthenticated IsAuthenticated IsAuthenticated

認証が成功したかどうかを示す Boolean 値を取得します。 Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted IsEncrypted IsEncrypted IsEncrypted

この SslStream がデータの暗号化を使用するかどうかを示す Boolean 値を取得します。 Gets a Boolean value that indicates whether this SslStream uses data encryption.

IsMutuallyAuthenticated IsMutuallyAuthenticated IsMutuallyAuthenticated IsMutuallyAuthenticated

サーバーとクライアントの両方が認証されているかどうかを示す Boolean 値を取得します。 Gets a Boolean value that indicates whether both server and client have been authenticated.

IsServer IsServer IsServer 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 IsSigned IsSigned IsSigned

このストリームを使用して送信されるデータに署名するかどうかを示す Boolean 値を取得します。 Gets a Boolean value that indicates whether the data sent using this stream is signed.

KeyExchangeAlgorithm KeyExchangeAlgorithm KeyExchangeAlgorithm KeyExchangeAlgorithm

この SslStream が使用するキー交換アルゴリズムを取得します。 Gets the key exchange algorithm used by this SslStream.

KeyExchangeStrength KeyExchangeStrength KeyExchangeStrength KeyExchangeStrength

このインスタンスが使用するキー交換アルゴリズムの強度を識別する値を取得します。 Gets a value that identifies the strength of the key exchange algorithm used by this instance.

LeaveInnerStreamOpen LeaveInnerStreamOpen LeaveInnerStreamOpen LeaveInnerStreamOpen

この AuthenticatedStream がデータの送受信に使用するストリームが、開いたままになっているかどうかを示す値を取得します。 Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(Inherited from AuthenticatedStream)
Length Length Length Length

基になるストリームの長さを取得します。 Gets the length of the underlying stream.

LocalCertificate LocalCertificate LocalCertificate LocalCertificate

ローカル エンドポイントの認証に使用する証明書を取得します。 Gets the certificate used to authenticate the local endpoint.

NegotiatedApplicationProtocol NegotiatedApplicationProtocol NegotiatedApplicationProtocol NegotiatedApplicationProtocol
Position Position Position Position

基になるストリーム内の現在位置を取得または設定します。 Gets or sets the current position in the underlying stream.

ReadTimeout ReadTimeout ReadTimeout ReadTimeout

読み取り操作がブロックしてデータを待機する時間を取得または設定します。 Gets or sets the amount of time a read operation blocks waiting for data.

RemoteCertificate RemoteCertificate RemoteCertificate RemoteCertificate

リモート エンドポイントの認証に使用する証明書を取得します。 Gets the certificate used to authenticate the remote endpoint.

SslProtocol SslProtocol SslProtocol SslProtocol

この接続の認証に使用するセキュリティ プロトコルを示す値を取得します。 Gets a value that indicates the security protocol used to authenticate this connection.

TransportContext TransportContext TransportContext TransportContext

拡張保護を使用した認証に使用する TransportContext を取得します。 Gets the TransportContext used for authentication using extended protection.

WriteTimeout WriteTimeout WriteTimeout WriteTimeout

書き込み操作がブロックしてデータを待機する時間を取得または設定します。 Gets or sets the amount of time a write operation blocks waiting for data.

方法

AuthenticateAsClient(String) AuthenticateAsClient(String) AuthenticateAsClient(String) AuthenticateAsClient(String)

サーバーおよび必要に応じてクライアントとサーバー間の接続にあるクライアントを認証するために、クライアントによって呼び出されます。 Called by clients to authenticate the server and optionally the client in a client-server connection.

AuthenticateAsClient(String, X509CertificateCollection, Boolean) AuthenticateAsClient(String, X509CertificateCollection, Boolean) AuthenticateAsClient(String, X509CertificateCollection, Boolean) 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) AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean) AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean) 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(SslClientAuthenticationOptions, CancellationToken) AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken) AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)
AuthenticateAsClientAsync(String) AuthenticateAsClientAsync(String) AuthenticateAsClientAsync(String) 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) AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean) AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean) 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) AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean) AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean) 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) AuthenticateAsServer(X509Certificate) AuthenticateAsServer(X509Certificate) 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) AuthenticateAsServer(X509Certificate, Boolean, Boolean) AuthenticateAsServer(X509Certificate, Boolean, Boolean) 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 sytem default security protocol.

AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean) AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean) AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean) 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(SslServerAuthenticationOptions, CancellationToken) AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken) AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)
AuthenticateAsServerAsync(X509Certificate) AuthenticateAsServerAsync(X509Certificate) AuthenticateAsServerAsync(X509Certificate) 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) AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean) AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean) 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) AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean) AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean) 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) BeginAuthenticateAsClient(String, AsyncCallback, Object) BeginAuthenticateAsClient(String, AsyncCallback, Object) 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) BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object) BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object) 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) BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object) BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object) 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) BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object) BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object) 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) BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object) BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object) 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) BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object) BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object) 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) BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) 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) BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

指定したバッファーからストリームに Byte を書き込む非同期書き込み操作を開始します。 Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

Close() Close() Close() 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.

(Inherited from Stream)
CopyTo(Stream) CopyTo(Stream) CopyTo(Stream) CopyTo(Stream)

現在のストリームからバイトを読み取り、別のストリームに書き込みます。 Reads the bytes from the current stream and writes them to another stream.

(Inherited from Stream)
CopyTo(Stream, Int32) CopyTo(Stream, Int32) CopyTo(Stream, Int32) CopyTo(Stream, Int32)

指定されたバッファー サイズを使用して、現在のストリームからバイトを読み取り、別のストリームに書き込みます。 Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Inherited from Stream)
CopyToAsync(Stream) CopyToAsync(Stream) CopyToAsync(Stream) CopyToAsync(Stream)

現在のストリームからすべてのバイトを非同期に読み取り、別のストリームに書き込みます。 Asynchronously reads the bytes from the current stream and writes them to another stream.

(Inherited from Stream)
CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken) Inherited from Stream
CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32)

指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、別のストリームに書き込みます。 Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Inherited from Stream)
CopyToAsync(Stream, Int32, CancellationToken) CopyToAsync(Stream, Int32, CancellationToken) CopyToAsync(Stream, Int32, CancellationToken) 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.

(Inherited from Stream)
CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

リモート オブジェクトとの通信に使用するプロキシの生成に必要な情報をすべて格納しているオブジェクトを作成します。 Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
CreateWaitHandle() CreateWaitHandle() CreateWaitHandle() CreateWaitHandle()

WaitHandle オブジェクトを割り当てます。 Allocates a WaitHandle object.

(Inherited from Stream)
Dispose() Dispose() Dispose() Dispose()

Stream によって使用されているすべてのリソースを解放します。 Releases all resources used by the Stream.

(Inherited from Stream)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

SslStream によって使用されているアンマネージド リソースを解放し、オプションでマネージド リソースも解放します。 Releases the unmanaged resources used by the SslStream and optionally releases the managed resources.

EndAuthenticateAsClient(IAsyncResult) EndAuthenticateAsClient(IAsyncResult) EndAuthenticateAsClient(IAsyncResult) EndAuthenticateAsClient(IAsyncResult)

BeginAuthenticateAsClient の以前の呼び出しで開始した保留中の非同期のサーバー認証操作を終了します。 Ends a pending asynchronous server authentication operation started with a previous call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult) EndAuthenticateAsServer(IAsyncResult) EndAuthenticateAsServer(IAsyncResult) EndAuthenticateAsServer(IAsyncResult)

BeginAuthenticateAsClient の以前の呼び出しで開始した保留中の非同期のクライアント認証操作を終了します。 Ends a pending asynchronous client authentication operation started with a previous call to BeginAuthenticateAsClient.

EndRead(IAsyncResult) EndRead(IAsyncResult) EndRead(IAsyncResult) 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) EndWrite(IAsyncResult) EndWrite(IAsyncResult) 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) Equals(Object) Equals(Object) Equals(Object)

指定したオブジェクトが、現在のオブジェクトと等しいかどうかを判断します。 Determines whether the specified object is equal to the current object.

(Inherited from Object)
Flush() Flush() Flush() Flush()

バッファーに格納されたデータが基になるデバイスに書き込まれるようにします。 Causes any buffered data to be written to the underlying device.

FlushAsync() FlushAsync() FlushAsync() FlushAsync()

ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Inherited from Stream)
FlushAsync(CancellationToken) FlushAsync(CancellationToken) FlushAsync(CancellationToken) FlushAsync(CancellationToken)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

既定のハッシュ関数として機能します。 Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

対象のインスタンスの有効期間ポリシーを制御する、現在の有効期間サービス オブジェクトを取得します。 Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

現在のインスタンスの Type を取得します。 Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

このインスタンスの有効期間ポリシーを制御する有効期間サービス オブジェクトを取得します。 Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

現在の Object の簡易コピーを作成します。 Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

現在の MarshalByRefObject オブジェクトの簡易コピーを作成します。 Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
ObjectInvariant() ObjectInvariant() ObjectInvariant() ObjectInvariant()

Contract のサポートを提供します。 Provides support for a Contract.

(Inherited from Stream)
Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32)

このストリームからデータを読み取り、指定した配列に格納します。 Reads data from this stream and stores it in the specified array.

Read(Span<Byte>) Read(Span<Byte>) Read(Span<Byte>) Read(Span<Byte>) Inherited from Stream
ReadAsync(Byte[], Int32, Int32) ReadAsync(Byte[], Int32, Int32) ReadAsync(Byte[], Int32, Int32) 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.

(Inherited from Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken) ReadAsync(Byte[], Int32, Int32, CancellationToken) ReadAsync(Byte[], Int32, Int32, CancellationToken) ReadAsync(Byte[], Int32, Int32, CancellationToken)

現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

(Inherited from Stream)
ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) Inherited from Stream
ReadByte() ReadByte() ReadByte() ReadByte()

ストリームから 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。ストリームの末尾の場合は -1 を返します。 Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

(Inherited from Stream)
Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin)

NotSupportedException をスローします。 Throws a NotSupportedException.

SetLength(Int64) SetLength(Int64) SetLength(Int64) SetLength(Int64)

基になるストリームの長さを設定します。 Sets the length of the underlying stream.

ShutdownAsync() ShutdownAsync() ShutdownAsync() ShutdownAsync()

この SslStream を終了します。 Shuts down this SslStream.

ToString() ToString() ToString() ToString()

現在のオブジェクトを表す文字列を返します。 Returns a string that represents the current object.

(Inherited from Object)
Write(Byte[]) Write(Byte[]) Write(Byte[]) Write(Byte[])

このストリームに指定したデータを書き込みます。 Writes the specified data to this stream.

Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32)

指定したバッファーとオフセットを使用して、基になるストリームに指定した Byte 数を書き込みます。 Write the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Inherited from Stream
WriteAsync(Byte[], Int32, Int32) WriteAsync(Byte[], Int32, Int32) WriteAsync(Byte[], Int32, Int32) 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.

(Inherited from Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken) WriteAsync(Byte[], Int32, Int32, CancellationToken) WriteAsync(Byte[], Int32, Int32, CancellationToken) WriteAsync(Byte[], Int32, Int32, CancellationToken)

現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

(Inherited from Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) Inherited from Stream
WriteByte(Byte) WriteByte(Byte) WriteByte(Byte) WriteByte(Byte)

ストリームの現在位置にバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Inherited from Stream)

明示的なインターフェイスの実装

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() Inherited from Stream

適用対象

こちらもご覧ください