SslStream Classe

Definizione

Fornisce un flusso usato per la comunicazione client-server che usa il protocollo di sicurezza SSL (Secure Socket Layer) per autenticare il server ed eventualmente il client.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
Ereditarietà
Implementazioni

Esempi

Nell'esempio di codice seguente viene illustrata la creazione SslStream di un oggetto TcpListener che utilizza la classe per comunicare con i client.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

Nell'esempio di codice riportato di seguito TcpClient viene illustrata SslStream la creazione di un oggetto che utilizza la classe per comunicare con un server.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

Commenti

I protocolli SSL consentono di garantire la riservatezza e il controllo dell'integrità dei SslStreammessaggi trasmessi tramite un.SSL protocols help to provide confidentiality and integrity checking for messages transmitted using an SslStream. Una connessione SSL, ad esempio quella fornita da SslStream, deve essere utilizzata per la comunicazione di informazioni riservate tra un client e un server.An SSL connection, such as that provided by SslStream, should be used when communicating sensitive information between a client and a server. L'uso SslStream di un oggetto consente di impedire a chiunque di leggere e manomettere le informazioni mentre è in transito sulla rete.Using an SslStream helps to prevent anyone from reading and tampering with information while it is in transit on the network.

Un' SslStream istanza trasmette i dati utilizzando un flusso fornito durante la creazione dell'oggetto SslStream.An SslStream instance transmits data using a stream that you supply when creating the SslStream. Quando si fornisce questo flusso sottostante, è possibile specificare se la chiusura SslStream di chiude anche il flusso sottostante.When you supply this underlying stream, you have the option to specify whether closing the SslStream also closes the underlying stream. In genere, SslStream la classe viene utilizzata con TcpClient le TcpListener classi e.Typically, the SslStream class is used with the TcpClient and TcpListener classes. Il GetStream metodo fornisce un NetworkStream oggetto adatto per l'utilizzo SslStream con la classe.The GetStream method provides a NetworkStream suitable for use with the SslStream class.

Dopo aver creato SslStreamun oggetto, il server e, facoltativamente, il client deve essere autenticato.After creating an SslStream, the server and optionally, the client must be authenticated. Il server deve fornire un certificato X509 che stabilisce la prova dell'identità e può richiedere anche che il client esegua questa operazione.The server must provide an X509 certificate that establishes proof of its identity and can request that the client also do so. È necessario eseguire l'autenticazione prima di trasmettere le SslStreaminformazioni utilizzando un oggetto.Authentication must be performed before transmitting information using an SslStream. I client avviano l'autenticazione usando AuthenticateAsClient i metodi sincroni, che si bloccano fino al completamento dell'autenticazione BeginAuthenticateAsClient o i metodi asincroni che non si bloccano in attesa del completamento dell'autenticazione.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. I server avviano l'autenticazione mediante AuthenticateAsServer i metodi BeginAuthenticateAsServer sincroni o asincroni.Servers initiate authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. Sia il client che il server devono avviare l'autenticazione.Both client and server must initiate the authentication.

L'autenticazione viene gestita dal provider del canale SSPI (Security Support Provider).The authentication is handled by the Security Support Provider (SSPI) channel provider. Al client viene data la possibilità di controllare la convalida del certificato del server specificando un RemoteCertificateValidationCallback delegato durante la creazione SslStreamdi un oggetto.The client is given an opportunity to control validation of the server's certificate by specifying a RemoteCertificateValidationCallback delegate when creating an SslStream. Il server può anche controllare la convalida fornendo un RemoteCertificateValidationCallback delegato.The server can also control validation by supplying a RemoteCertificateValidationCallback delegate. Il metodo a cui fa riferimento il delegato include il certificato della parte remota e gli eventuali errori SSPI rilevati durante la convalida del certificato.The method referenced by the delegate includes the remote party's certificate and any errors SSPI encountered while validating the certificate. Si noti che se il server specifica un delegato, il metodo del delegato viene richiamato indipendentemente dal fatto che il server abbia richiesto l'autenticazione client.Note that if the server specifies a delegate, the delegate's method is invoked regardless of whether the server requested client authentication. Se il server non ha richiesto l'autenticazione client, il metodo delegato del server riceve un certificato null e una matrice vuota di errori del certificato.If the server did not request client authentication, the server's delegate method receives a null certificate and an empty array of certificate errors.

Se il server richiede l'autenticazione client, il client deve specificare uno o più certificati per l'autenticazione.If the server requires client authentication, the client must specify one or more certificates for authentication. Se il client dispone di più di un certificato, il client può fornire LocalCertificateSelectionCallback un delegato per selezionare il certificato corretto per il server.If the client has more than one certificate, the client can provide a LocalCertificateSelectionCallback delegate to select the correct certificate for the server. I certificati del client devono trovarsi nell'archivio certificati "My" dell'utente corrente.The client's certificates must be located in the current user's "My" certificate store. L'autenticazione client tramite certificati non è supportata per Ssl2 il protocollo (SSL versione 2).Client authentication via certificates is not supported for the Ssl2 (SSL version 2) protocol.

Se l'autenticazione ha esito negativo, AuthenticationExceptionviene visualizzato un SslStream oggetto e non è più utilizzabile.If the authentication fails, you receive a AuthenticationException, and the SslStream is no longer useable. È necessario chiudere questo oggetto e rimuovere tutti i riferimenti in modo che possano essere raccolti dal Garbage Collector.You should close this object and remove all references to it so that it can be collected by the garbage collector.

Quando il processo di autenticazione, noto anche come handshake SSL, ha esito positivo, viene stabilita l'identità del server (e, facoltativamente, il client SslStream ) e il può essere utilizzato dal client e dal server per scambiare messaggi.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. Prima SslStream di inviare o ricevere informazioni, il client e il server devono verificare i servizi e i livelli di sicurezza forniti da per determinare se il protocollo, gli algoritmi e i punti di forza selezionati soddisfino i requisiti di integrità e riservatezza.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. Se le impostazioni correnti non sono sufficienti, il flusso deve essere chiuso.If the current settings are not sufficient, the stream should be closed. È possibile controllare i servizi di sicurezza forniti da SslStream usando le IsEncrypted proprietà IsSigned e.You can check the security services provided by the SslStream using the IsEncrypted and IsSigned properties. La tabella seguente Mostra gli elementi che indicano le impostazioni di crittografia usate per l'autenticazione, la crittografia e la firma dei dati.The following table shows the elements that report the cryptographic settings used for authentication, encryption and data signing.

ElementoElement MembriMembers
Il protocollo di sicurezza utilizzato per autenticare il server e, facoltativamente, il client.The security protocol used to authenticate the server and, optionally, the client. Proprietà e Enumerazione associata SslProtocols. SslProtocolThe SslProtocol property and the associated SslProtocols enumeration.
Algoritmo di scambio delle chiavi.The key exchange algorithm. Proprietà e Enumerazione associata ExchangeAlgorithmType. KeyExchangeAlgorithmThe KeyExchangeAlgorithm property and the associated ExchangeAlgorithmType enumeration.
Algoritmo di integrità del messaggio.The message integrity algorithm. Proprietà e Enumerazione associata HashAlgorithmType. HashAlgorithmThe HashAlgorithm property and the associated HashAlgorithmType enumeration.
Algoritmo di riservatezza dei messaggi.The message confidentiality algorithm. Proprietà e Enumerazione associata CipherAlgorithmType. CipherAlgorithmThe CipherAlgorithm property and the associated CipherAlgorithmType enumeration.
Punti di forza degli algoritmi selezionati.The strengths of the selected algorithms. Proprietà KeyExchangeStrength, HashStrengthe .CipherStrengthThe KeyExchangeStrength, HashStrength, and CipherStrength properties.

Una volta completata l'autenticazione, è possibile inviare i dati utilizzando Write i metodi BeginWrite sincroni o asincroni.After a successful authentication, you can send data using the synchronous Write or asynchronous BeginWrite methods. È possibile ricevere dati usando i metodi Read sincroni o BeginRead asincroni.You can receive data using the synchronous Read or asynchronous BeginRead methods.

Se è stato specificato SslStream che il flusso sottostante deve essere lasciato aperto, si è responsabili della chiusura del flusso al termine dell'utilizzo.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.

Nota

Se l'applicazione che crea l' SslStream oggetto viene eseguita con le credenziali di un utente normale, l'applicazione non sarà in grado di accedere ai certificati installati nell'archivio del computer locale, a meno che l'autorizzazione non sia stata esplicitamente assegnata all'utente a tale scopo.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.

SslStreampresuppone che un timeout insieme a qualsiasi altro IOException quando ne viene generata una dal flusso interno venga considerato irreversibile dal chiamante.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. Il riutilizzo SslStream di un'istanza dopo un timeout restituirà un'operazione di Garbage Collection.Reusing a SslStream instance after a timeout will return garbage. In questi casi Close SslStream , un'applicazione deve generare un'eccezione.An application should Close the SslStream and throw an exception in these cases.

Il .NET Framework 4,6 include una nuova funzionalità di sicurezza che blocca gli algoritmi di crittografia e hashing non protetti per le connessioni.The .NET Framework 4.6 includes a new security feature that blocks insecure cipher and hashing algorithms for connections. Le applicazioni che usano TLS/SSL tramite API come HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream e così via e destinate a .NET Framework 4,6 ottengono il comportamento più sicuro per impostazione predefinita.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.

Gli sviluppatori potrebbero voler rifiutare esplicitamente questo comportamento per mantenere l'interoperabilità con i servizi SSL3 esistenti o con i servizi TLS w/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. Questo articolo illustra come modificare il codice in modo che il nuovo comportamento sia disabilitato.This article explains how to modify your code so that the new behavior is disabled.

Il .NET Framework 4,7 aggiunge nuovi overload per i metodi che autenticano SslStreams che non specificano una versione TLS, ma usano invece la versione TLS definita come impostazione predefinita del sistema in 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. Usare questi metodi nell'app come metodo per poter modificare in un secondo momento le impostazioni predefinite come le procedure consigliate per la versione di TLS, senza dover ricompilare e ridistribuire l'app.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.

Vedere anche procedure consigliate Transport Layer Security (TLS) con la .NET Framework.Also see Transport Layer Security (TLS) best practices with the .NET Framework.

Costruttori

SslStream(Stream)

Inizializza una nuova istanza della classe SslStream usando il Stream specificato.Initializes a new instance of the SslStream class using the specified Stream.

SslStream(Stream, Boolean)

Inizializza una nuova istanza della classe SslStream tramite l'oggetto Stream specificato e il comportamento di chiusura del flusso.Initializes a new instance of the SslStream class using the specified Stream and stream closure behavior.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback)

Inizializza una nuova istanza della classe SslStream tramite l'oggetto Stream specificato, il comportamento di chiusura del flusso e il delegato di convalida del certificato.Initializes a new instance of the SslStream class using the specified Stream, stream closure behavior and certificate validation delegate.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)

Inizializza una nuova istanza della classe SslStream tramite l'oggetto Stream specificato, il comportamento di chiusura del flusso, il delegato di convalida del certificato e il delegato di selezione del certificato.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)

Inizializza una nuova istanza della classe SslStream tramite l'oggetto Stream specificato.Initializes a new instance of the SslStream class using the specified Stream

Proprietà

CanRead

Ottiene un valore Booleanche indica se il flusso sottostante è leggibile.Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek

Ottiene un valore Boolean che indica se il flusso sottostante consente le ricerche.Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout

Ottiene un valore Boolean che indica se il flusso sottostante supporta i timeout.Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite

Ottiene un valore Boolean che indica se è possibile scrivere nel flusso sottostante.Gets a Boolean value that indicates whether the underlying stream is writable.

CheckCertRevocationStatus

Ottiene un valore Boolean che indica se l'elenco certificati revocati viene verificato durante il processo di convalida del certificato.Gets a Boolean value that indicates whether the certificate revocation list is checked during the certificate validation process.

CipherAlgorithm

Ottiene un valore che identifica l'algoritmo di crittografia di massa utilizzato dalla classe SslStream.Gets a value that identifies the bulk encryption algorithm used by this SslStream.

CipherStrength

Ottiene un valore che identifica il livello dell'algoritmo di crittografia utilizzato dalla classe SslStream.Gets a value that identifies the strength of the cipher algorithm used by this SslStream.

HashAlgorithm

Ottiene l'algoritmo utilizzato per generare codici di autenticazione MAC (Message Authentication Code).Gets the algorithm used for generating message authentication codes (MACs).

HashStrength

Ottiene un valore che identifica il livello dell'algoritmo di hash utilizzato da questa istanza.Gets a value that identifies the strength of the hash algorithm used by this instance.

InnerStream

Ottiene il flusso utilizzato dalla classe AuthenticatedStream per inviare e ricevere dati.Gets the stream used by this AuthenticatedStream for sending and receiving data.

(Ereditato da AuthenticatedStream)
IsAuthenticated

Ottiene un valore Boolean che indica se l'autenticazione è stata effettuata con esito positivo.Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted

Ottiene un valore Boolean che indica se la classe SslStream utilizza la crittografia dei dati.Gets a Boolean value that indicates whether this SslStream uses data encryption.

IsMutuallyAuthenticated

Ottiene un valore Boolean che indica se il client e il server sono stati entrambi autenticati.Gets a Boolean value that indicates whether both server and client have been authenticated.

IsServer

Ottiene un valore Boolean che indica se il lato locale della connessione utilizzato da questa classe SslStream è stato autenticato come il server.Gets a Boolean value that indicates whether the local side of the connection used by this SslStream was authenticated as the server.

IsSigned

Ottiene un valore Boolean che indica se i dati inviati utilizzando questo flusso vengono firmati.Gets a Boolean value that indicates whether the data sent using this stream is signed.

KeyExchangeAlgorithm

Ottiene l'algoritmo di scambio delle chiavi utilizzato dalla classe SslStream.Gets the key exchange algorithm used by this SslStream.

KeyExchangeStrength

Ottiene un valore che identifica il livello dell'algoritmo di scambio delle chiavi utilizzato da questa istanza.Gets a value that identifies the strength of the key exchange algorithm used by this instance.

LeaveInnerStreamOpen

Consente di sapere se il flusso utilizzato dalla classe AuthenticatedStream per inviare e ricevere dati è stato lasciato aperto.Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(Ereditato da AuthenticatedStream)
Length

Ottiene la lunghezza del flusso sottostante.Gets the length of the underlying stream.

LocalCertificate

Ottiene il certificato utilizzato per autenticare l'endpoint locale.Gets the certificate used to authenticate the local endpoint.

NegotiatedApplicationProtocol
NegotiatedCipherSuite

Ottiene il pacchetto di crittografia negoziato per la connessione.Gets the cipher suite which was negotiated for this connection.

Position

Ottiene o imposta la posizione corrente nel flusso sottostante.Gets or sets the current position in the underlying stream.

ReadTimeout

Ottiene o imposta l'intervallo di tempo, espresso in millisecondi, per il quale un'operazione di lettura si blocca in attesa dei dati.Gets or sets the amount of time, expressed in milliseconds, a read operation blocks waiting for data.

RemoteCertificate

Ottiene il certificato utilizzato per autenticare l'endpoint remoto.Gets the certificate used to authenticate the remote endpoint.

SslProtocol

Ottiene un valore che indica il certificato di sicurezza utilizzato per autenticare questa connessione.Gets a value that indicates the security protocol used to authenticate this connection.

TransportContext

Ottiene l'oggetto TransportContext utilizzato per l'autenticazione tramite la protezione estesa.Gets the TransportContext used for authentication using extended protection.

WriteTimeout

Ottiene o imposta l'intervallo di tempo durante il quale un'operazione di scrittura si blocca in attesa dei dati.Gets or sets the amount of time a write operation blocks waiting for data.

Metodi

AuthenticateAsClient(String)

Chiamato dai client per autenticare il server e, facoltativamente, il client in una connessione client-server.Called by clients to authenticate the server and optionally the client in a client-server connection.

AuthenticateAsClient(String, X509CertificateCollection, Boolean)

Chiamato dai client per autenticare il server e, facoltativamente, il client in una connessione client-server.Called by clients to authenticate the server and optionally the client in a client-server connection. Il processo di autenticazione usa la raccolta di certificati specificata e il protocollo SSL predefinito di sistema.The authentication process uses the specified certificate collection, and the system default SSL protocol.

AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)

Chiamato dai client per autenticare il server e, facoltativamente, il client in una connessione client-server.Called by clients to authenticate the server and optionally the client in a client-server connection. Nel processo di autenticazione vengono utilizzati l'insieme di certificati specificato e il protocollo SSL.The authentication process uses the specified certificate collection and SSL protocol.

AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)
AuthenticateAsClientAsync(String)

Chiamato dai client per autenticare il server e, facoltativamente, il client in una connessione client-server come operazione asincrona.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)

Chiamato dai client per autenticare il server e, facoltativamente, il client in una connessione client-server come operazione asincrona.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Il processo di autenticazione usa la raccolta di certificati specificata e il protocollo SSL predefinito di sistema.The authentication process uses the specified certificate collection and the system default SSL protocol.

AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)

Chiamato dai client per autenticare il server e, facoltativamente, il client in una connessione client-server come operazione asincrona.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Nel processo di autenticazione vengono utilizzati l'insieme di certificati specificato e il protocollo SSL.The authentication process uses the specified certificate collection and SSL protocol.

AuthenticateAsServer(X509Certificate)

Viene chiamato dai server per l'autenticazione del server e, facoltativamente, del client, in una connessione client-server che utilizza il certificato specificato.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificate.

AuthenticateAsServer(X509Certificate, Boolean, Boolean)

Chiamato dai server per autenticare il server e, facoltativamente, il client in una connessione client-server usando i certificati e i requisiti specificati nonché il protocollo di sicurezza predefinito del sistema.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)

Chiamato dai server per autenticare il server ed eventualmente il client in una connessione client-server usando i certificati, i requisiti e il protocollo di sicurezza specificati.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates, requirements and security protocol.

AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)
AuthenticateAsServerAsync(X509Certificate)

Viene chiamato dai server per l'autenticazione del server e, facoltativamente, del client, in una connessione client-server che utilizza il certificato specificato come un'operazione asincrona.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)

Chiamato dai server per autenticare il server ed eventualmente il client in una connessione client-server usando i certificati specificati, i requisiti e il protocollo di sicurezza come operazione asincrona.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)

Chiamato dai server per autenticare il server ed eventualmente il client in una connessione client-server usando i certificati specificati, i requisiti e il protocollo di sicurezza come operazione asincrona.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)

Viene chiamato dai client per avviare un'operazione asincrona di autenticazione del server e, facoltativamente, del client.Called by clients to begin an asynchronous operation to authenticate the server and optionally the client.

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

Chiamato dai client per avviare un'operazione asincrona per autenticare il server e, facoltativamente, il client usando i certificati specificati e il protocollo di sicurezza predefinito del sistema.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)

Viene chiamato dai client per avviare un'operazione asincrona di autenticazione del server e, facoltativamente, del client, utilizzando i certificati e il protocollo di sicurezza specificati.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)

Viene chiamato dai server per avviare un'operazione asincrona di autenticazione del client e, facoltativamente, del server, in una connessione client-server.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)

Chiamato dai server per avviare un'operazione asincrona per autenticare il server e, facoltativamente, il client usando i certificati e i requisiti specificati nonché il protocollo di sicurezza predefinito del sistema.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)

Chiamato dai server per avviare un'operazione asincrona per autenticare il server ed eventualmente il client usando i certificati, i requisiti e il protocollo di sicurezza specificati.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)

Avvia un'operazione di lettura asincrona dei dati del flusso, archiviandoli nella matrice specificata.Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

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

Avvia un'operazione di scrittura asincrona che scrive i Byte dal buffer specificato nel flusso.Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

Close()

Chiude il flusso corrente e libera le risorse, come socket e handle di file, ad esso associate.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Anziché chiamare questo metodo, assicurarsi che il flusso sia eliminato correttamente.Instead of calling this method, ensure that the stream is properly disposed.

(Ereditato da Stream)
CopyTo(Stream)

Legge i byte dal flusso corrente e li scrive in un altro flusso.Reads the bytes from the current stream and writes them to another stream.

(Ereditato da Stream)
CopyTo(Stream, Int32)

Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Ereditato da Stream)
CopyToAsync(Stream)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso.Asynchronously reads the bytes from the current stream and writes them to another stream.

(Ereditato da Stream)
CopyToAsync(Stream, CancellationToken)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando un token di annullamento specificato.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(Ereditato da Stream)
CopyToAsync(Stream, Int32)

Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, utilizzando una dimensione di buffer specificata.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Ereditato da Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(Ereditato da Stream)
CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Ereditato da MarshalByRefObject)
CreateWaitHandle()

Alloca un oggetto WaitHandle.Allocates a WaitHandle object.

(Ereditato da Stream)
Dispose()

Rilascia tutte le risorse usate da Stream.Releases all resources used by the Stream.

(Ereditato da Stream)
Dispose(Boolean)

Rilascia le risorse non gestite usate da SslStream e, facoltativamente, le risorse gestite.Releases the unmanaged resources used by the SslStream and optionally releases the managed resources.

DisposeAsync()

Consente di liberare in modo asincrono le risorse non gestite e gestite usate da SslStream.Asynchronously releases the unmanaged and managed resources used by the SslStream.

EndAuthenticateAsClient(IAsyncResult)

Termina un'operazione di autenticazione server asincrona in sospeso avviata con una precedente chiamata del metodo BeginAuthenticateAsClient.Ends a pending asynchronous server authentication operation started with a previous call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

Termina un'operazione di autenticazione client asincrona in sospeso avviata con una precedente chiamata del metodo BeginAuthenticateAsClient.Ends a pending asynchronous client authentication operation started with a previous call to BeginAuthenticateAsClient.

EndRead(IAsyncResult)

Termina un'operazione di lettura asincrona avviata con una precedente chiamata del metodo 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)

Termina un'operazione di scrittura asincrona avviata con una precedente chiamata del metodo 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)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
Flush()

Consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante.Causes any buffered data to be written to the underlying device.

FlushAsync()

Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Ereditato da Stream)
FlushAsync(CancellationToken)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
InitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Ereditato da MarshalByRefObject)
ObjectInvariant()

Fornisce supporto per un oggetto Contract.Provides support for a Contract.

(Ereditato da Stream)
Read(Byte[], Int32, Int32)

Legge i dati da questo flusso e li archivia nella matrice specificata.Reads data from this stream and stores it in the specified array.

Read(Span<Byte>)

Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti.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.

(Ereditato da Stream)
ReadAsync(Byte[], Int32, Int32)

Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Ereditato da Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Legge in modo asincrono i dati da questo flusso e li archivia nell'intervallo specificato di una matrice di byte.Asynchronously reads data from this stream and stores it in the specified range of a byte array.

ReadAsync(Memory<Byte>, CancellationToken)

Legge in modo asincrono i dati da questo flusso e li archivia nell'intervallo di memoria specificato.Asynchronously reads data from this stream and stores it in the specified memory range.

ReadByte()

Legge un byte da SslStream e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso.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)

Genera un oggetto NotSupportedException.Throws a NotSupportedException.

SetLength(Int64)

Imposta la lunghezza del flusso sottostante.Sets the length of the underlying stream.

ShutdownAsync()

Arresta questo oggetto SslStream.Shuts down this SslStream.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
Write(Byte[])

Scrive i dati specificati in questo flusso.Writes the specified data to this stream.

Write(Byte[], Int32, Int32)

Consente di scrivere il numero specificato di Byte nel flusso sottostante, utilizzando il buffer e l'offset specificati.Write the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>)

Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti.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.

(Ereditato da Stream)
WriteAsync(Byte[], Int32, Int32)

Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Ereditato da Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Scrive in modo asincrono i dati nel flusso sottostante dall'intervallo specificato di una matrice di byte.Asynchronously writes data to the underlying stream from the specified range of a byte array.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Scrive in modo asincrono i dati nel flusso sottostante da un intervallo di memoria di byte di sola lettura.Asynchronously writes data to the underlying stream from a read-only byte memory range.

WriteByte(Byte)

Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Ereditato da Stream)

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Rilascia tutte le risorse usate da Stream.Releases all resources used by the Stream.

(Ereditato da Stream)

Si applica a

Vedi anche