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

次のコード例は、 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;
        }
    }
}
    
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. サーバーは、その id の証明を確立する X509 証明書を提供する必要があります。また、クライアントにも要求することができます。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 (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. プロパティSslStream IsEncryptedとプロパティIsSignedを使用して、によって提供されるセキュリティサービスを確認できます。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. プロパティおよび関連付けらSslProtocolsれている列挙体。 SslProtocolThe SslProtocol property and the associated SslProtocols enumeration.
キー交換アルゴリズム。The key exchange algorithm. プロパティおよび関連付けらExchangeAlgorithmTypeれている列挙体。 KeyExchangeAlgorithmThe KeyExchangeAlgorithm property and the associated ExchangeAlgorithmType enumeration.
メッセージの整合性アルゴリズム。The message integrity algorithm. プロパティおよび関連付けらHashAlgorithmTypeれている列挙体。 HashAlgorithmThe HashAlgorithm property and the associated HashAlgorithmType enumeration.
メッセージの機密性アルゴリズム。The message confidentiality algorithm. プロパティおよび関連付けらCipherAlgorithmTypeれている列挙体。 CipherAlgorithmThe CipherAlgorithm property and the associated CipherAlgorithmType enumeration.
選択されたアルゴリズムの強度。The strengths of the selected algorithms. 、、 KeyExchangeStrengthおよびCipherStrengthの各プロパティ。 HashStrengthThe 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. アプリケーションは、 CloseこのSslStreamような場合に、例外をスローする必要があります。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.

開発者は、既存の SSL3 サービスや TLS (RC4) サービスとの相互運用性を維持するために、この動作を無効にすることができます。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) SslStream(Stream) SslStream(Stream)

指定した Stream を使用して SslStream クラスの新しいインスタンスを初期化します。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
NegotiatedCipherSuite NegotiatedCipherSuite NegotiatedCipherSuite NegotiatedCipherSuite

この接続に対してネゴシエートされた暗号スイートを取得します。Gets the cipher suite which was negotiated for this connection.

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, expressed in milliseconds, 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 system 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)

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

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

DisposeAsync() DisposeAsync() DisposeAsync() DisposeAsync()

SslStream によって使用されているアンマネージドまたはマネージド リソースを非同期に解放します。Asynchronously releases the unmanaged and managed resources used by the SslStream.

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>)

派生クラスによってオーバーライドされた場合は、現在のストリームからバイト シーケンスを読み取り、読み取ったバイト数の分だけストリームの位置を進めます。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.

(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 data from this stream and stores it in the specified range of a byte array.

ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken)

このストリームからデータを非同期的に読み取り、それを指定されたメモリ範囲に格納します。Asynchronously reads data from this stream and stores it in the specified memory range.

ReadByte() ReadByte() ReadByte() ReadByte()

SslStream から 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。または、ストリームの末尾の場合は -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) 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>)

派生クラスによってオーバーライドされた場合は、現在のストリームにバイト シーケンスを書き込み、書き込んだバイト数の分だけストリームの現在位置を進めます。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.

(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 data to the underlying stream from the specified range of a byte array.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

読み取り専用バイト メモリ範囲から基になるストリームにデータを非同期的に書き込みます。Asynchronously writes data to the underlying stream from a read-only byte memory range.

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

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

(Inherited from Stream)

適用対象

こちらもご覧ください