Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Classe SslStream

Fornece um fluxo usado para comunicação cliente-servidor que usa o protocolo de segurança Secure Socket Layer (SSL) para autenticar o servidor e opcionalmente o cliente.

Namespace:  System.Net.Security
Assembly:  System (em System.dll)

public class SslStream : AuthenticatedStream

O tipo SslStream expõe os membros a seguir.

  NomeDescrição
Método públicoSslStream(Stream)Inicializa uma nova instância da classe SslStream que usa Streamespecificado.
Método públicoSslStream(Stream, Boolean)Inicializa uma nova instância da classe SslStream que usa Stream e o comportamento especificado de fechamento de fluxo.
Método públicoSslStream(Stream, Boolean, RemoteCertificateValidationCallback)Inicializa uma nova instância da classe SslStream que usa Stream, o comportamento de fechamento de fluxo e o representante especificado de validação de certificado.
Método públicoSslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)Inicializa uma nova instância da classe SslStream que usa Stream, o comportamento de fechamento de fluxo, o representante de validação de certificado e o representante especificado de seleção de certificado.
Método públicoSslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)Inicializa uma nova instância da classe SslStream que usa Streamespecificado
Superior

  NomeDescrição
Propriedade públicaCanReadObtém um valor de Boolean que indica se o fluxo subjacente é legível. (Substitui Stream.CanRead.)
Propriedade públicaCanSeekObtém um valor de Boolean que indica se o fluxo subjacente é seekable. (Substitui Stream.CanSeek.)
Propriedade públicaCanTimeoutObtém um valor de Boolean que indica se o fluxo subjacente suporte intervalos. (Substitui Stream.CanTimeout.)
Propriedade públicaCanWriteObtém um valor de Boolean que indica se o fluxo subjacente é modificável. (Substitui Stream.CanWrite.)
Propriedade públicaCheckCertRevocationStatusObtém um valor de Boolean que indica se a lista de certificados revogados é verificada durante o processo de validação de certificado.
Propriedade públicaCipherAlgorithmObtém um valor que identifica o algoritmo de criptografia em massa usado por esse SslStream.
Propriedade públicaCipherStrengthObtém um valor que identifica a força o algoritmo de cifra usado por esse SslStream.
Propriedade públicaHashAlgorithmObtém o algoritmo usado para gerar código (MACs) de autenticação de mensagem.
Propriedade públicaHashStrengthObtém um valor que identifica a força o algoritmo de hash usado por essa instância.
Propriedade protegidaInnerStreamObtém o fluxo usado por este AuthenticatedStream para enviar e receber dados. (Herdado de AuthenticatedStream.)
Propriedade públicaIsAuthenticatedObtém um valor de Boolean que indica se a autenticação for bem-sucedida. (Substitui AuthenticatedStream.IsAuthenticated.)
Propriedade públicaIsEncryptedObtém um valor de Boolean que indica se este SslStream usa a criptografia de dados. (Substitui AuthenticatedStream.IsEncrypted.)
Propriedade públicaIsMutuallyAuthenticatedObtém um valor de Boolean que indica se o servidor e o cliente foram autenticados. (Substitui AuthenticatedStream.IsMutuallyAuthenticated.)
Propriedade públicaIsServerObtém um valor de Boolean que indica se o lado do local de conexão usada por esse SslStream foi autenticado como o servidor. (Substitui AuthenticatedStream.IsServer.)
Propriedade públicaIsSignedObtém um valor de Boolean que indica se os dados enviados usando esse fluxo são assinados. (Substitui AuthenticatedStream.IsSigned.)
Propriedade públicaKeyExchangeAlgorithmObtém o algoritmo de troca de chaves usado por esse SslStream.
Propriedade públicaKeyExchangeStrengthObtém um valor que identifica a força o algoritmo de troca de chaves usado por essa instância.
Propriedade públicaLeaveInnerStreamOpenObtém se o fluxo usados por isso AuthenticatedStream para enviar e receber dados foi deixado aberto. (Herdado de AuthenticatedStream.)
Propriedade públicaLengthObtém o comprimento de fluxo subjacente. (Substitui Stream.Length.)
Propriedade públicaLocalCertificateObtém o certificado usado para autenticar o ponto de extremidade local.
Propriedade públicaPositionObtém ou define a posição atual no fluxo subjacente. (Substitui Stream.Position.)
Propriedade públicaReadTimeoutObtém ou define a quantidade de tempo blocos de uma operação de leitura que esperam dados. (Substitui Stream.ReadTimeout.)
Propriedade públicaRemoteCertificateObtém o certificado usado para autenticar o ponto de extremidade remoto.
Propriedade públicaSslProtocolObtém um valor que indica o protocolo de segurança usado para autenticar a conexão.
Propriedade públicaTransportContextObtém TransportContext usado para autenticação usando a proteção estendida.
Propriedade públicaWriteTimeoutObtém ou define a quantidade de tempo blocos de uma operação de escrita que esperam dados. (Substitui Stream.WriteTimeout.)
Superior

  NomeDescrição
Método públicoAuthenticateAsClient(String)Chamado por clientes para autenticar o servidor e opcionalmente o cliente em uma conexão do servidor cliente.
Método públicoAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)Chamado por clientes para autenticar o servidor e opcionalmente o cliente em uma conexão do servidor cliente. O processo de autenticação usa a coleção de certificado e o protocolo SSL especificados.
Método públicoAuthenticateAsClientAsync(String)Chamado por clientes para autenticar o servidor e opcionalmente o cliente em uma conexão do servidor cliente como uma operação assíncrona.
Método públicoAuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)Chamado por clientes para autenticar o servidor e opcionalmente o cliente em uma conexão do servidor cliente como uma operação assíncrona. O processo de autenticação usa a coleção de certificado e o protocolo SSL especificados.
Método públicoAuthenticateAsServer(X509Certificate)Chamado por servidores para autenticar o servidor e opcionalmente o cliente em uma conexão do servidor cliente usando o certificado especificado.
Método públicoAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)Chamado por servidores para autenticar o servidor e opcionalmente o cliente em uma conexão do servidor cliente usando certificados, os requisitos e o protocolo de segurança especificados.
Método públicoAuthenticateAsServerAsync(X509Certificate)Chamado por servidores para autenticar o servidor e opcionalmente o cliente em uma conexão do servidor cliente usando o certificado especificado como uma operação assíncrona.
Método públicoAuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)Chamado por servidores para autenticar o servidor e opcionalmente o cliente em uma conexão do servidor cliente usando certificados, os requisitos e o protocolo de segurança especificados como uma operação assíncrona.
Método públicoBeginAuthenticateAsClient(String, AsyncCallback, Object)Chamado por clientes para iniciar uma operação assíncrona a autenticar o servidor e opcionalmente o cliente.
Método públicoBeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)Chamado por clientes para iniciar uma operação assíncrona a autenticar o servidor e opcionalmente o cliente que usa os certificados e o protocolo de segurança especificados.
Método públicoBeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)Chamado por servidores para iniciar uma operação assíncrona a autenticar o cliente e opcionalmente o servidor em uma conexão do servidor cliente.
Método públicoBeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)Chamado por servidores para iniciar uma operação assíncrona a autenticar o servidor e opcionalmente o cliente que usa os certificados, os requisitos e o protocolo de segurança especificados.
Método públicoBeginReadIniciar uma operação de leitura assíncrono que lê dados de fluxo e os armazena na matriz especificada. (Substitui Stream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).)
Método públicoBeginWriteIniciar uma operação de gravação assíncrono que grava Bytes de buffer especificado para o fluxo. (Substitui Stream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).)
Método públicoCloseFecha o fluxo atual e libera todos os recursos (como soquetes e os identificadores de arquivo) associados ao fluxo atual. Em vez de chamar esse método, verifique se o fluxo seja descartado corretamente. (Herdado de Stream.)
Método públicoCopyTo(Stream) Lê os bytes do fluxo atual e os grava em outro fluxo. (Herdado de Stream.)
Método públicoCopyTo(Stream, Int32) Lê os bytes do fluxo atual e os grava em outro fluxo, usando um tamanho de buffer especificado. (Herdado de Stream.)
Método públicoCopyToAsync(Stream) Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo. (Herdado de Stream.)
Método públicoCopyToAsync(Stream, Int32) Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo, usando um tamanho de buffer especificado. (Herdado de Stream.)
Método públicoCopyToAsync(Stream, Int32, CancellationToken) Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo, usando um tamanho de buffer especificado e token de cancelamento. (Herdado de Stream.)
Método públicoCreateObjRefCria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject.)
Método protegidoCreateWaitHandle Obsoleta. Atribui um objeto de WaitHandle. (Herdado de Stream.)
Método públicoDispose()Libera todos os recursos usados por Stream. (Herdado de Stream.)
Método protegidoDispose(Boolean)Libera os recursos não gerenciados usados pelo SslStream e opcionalmente libera os recursos gerenciados. (Substitui AuthenticatedStream.Dispose(Boolean).)
Método públicoEndAuthenticateAsClientTermina uma operação assíncrona pendente de autenticação de servidor iniciada por uma chamada anterior a BeginAuthenticateAsServer.
Método públicoEndAuthenticateAsServerTermina uma operação assíncrona pendente de autenticação de cliente iniciada por uma chamada anterior a BeginAuthenticateAsClient.
Método públicoEndReadTermina uma operação de leitura assíncrono iniciada por uma chamada anterior ao BeginRead. (Substitui Stream.EndRead(IAsyncResult).)
Método públicoEndWriteTermina uma operação de gravação assíncrono iniciada por uma chamada anterior ao BeginWrite. (Substitui Stream.EndWrite(IAsyncResult).)
Método públicoEquals(Object) Verifica se o objeto especificado é igual ao objeto atual. (Herdado de Object.)
Método protegidoFinalize Permite um objeto tentar liberar recursos e executar outras operações de limpeza antes que ele seja recuperado pela coleta de lixo. (Herdado de Object.)
Método públicoFlushFaz com que todos os dados armazenados em buffer a serem gravados para o dispositivo subjacente. (Substitui Stream.Flush().)
Método públicoFlushAsync() Limpa de forma assíncrona todos os buffers deste fluxo e faz com que todos os dados em buffer sejam gravados no dispositivo subjacente. (Herdado de Stream.)
Método públicoFlushAsync(CancellationToken) Limpa de forma assíncrona todos os buffers para esse fluxo, faz com que todos os dados em buffer sejam gravados no dispositivo subjacente, e monitora solicitações de cancelamento. (Herdado de Stream.)
Método públicoGetHashCodeServe como a função de hash padrão. (Herdado de Object.)
Método públicoGetLifetimeService Recupera o objeto atual de serviço de vida útil que controla a diretiva de vida útil para esta instância. (Herdado de MarshalByRefObject.)
Método públicoGetType Obtém o Type da instância atual. (Herdado de Object.)
Método públicoInitializeLifetimeService Obtém um objeto de serviço de tempo de vida para controlar a diretiva de vida útil para esta instância. (Herdado de MarshalByRefObject.)
Método protegidoMemberwiseClone()Cria uma cópia superficial do Object atual. (Herdado de Object.)
Método protegidoMemberwiseClone(Boolean) Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject.)
Método protegidoObjectInvariantInfraestrutura. Obsoleta. Fornece suporte para Contract. (Herdado de Stream.)
Método públicoReadLer dados desse fluxo e armazená-las na matriz especificada. (Substitui Stream.Read(Byte[], Int32, Int32).)
Método públicoReadAsync(Byte[], Int32, Int32) Lê de forma assíncrona uma sequência de bytes do fluxo atual e avança a posição do fluxo pelo número de bytes. (Herdado de Stream.)
Método públicoReadAsync(Byte[], Int32, Int32, CancellationToken) Lê de forma assíncrona uma sequência de bytes do fluxo atual, avança a posição do fluxo pelo número de bytes, e monitora solicitações de cancelamento. (Herdado de Stream.)
Método públicoReadByteLê um fluxo de bytes e avança a posição dentro do fluxo por um byte, ou retornará -1 se ao término do fluxo. (Herdado de Stream.)
Método públicoSeekInfraestrutura. Gera NotSupportedException. (Substitui Stream.Seek(Int64, SeekOrigin).)
Método públicoSetLengthDefina o tamanho do fluxo subjacente. (Substitui Stream.SetLength(Int64).)
Método públicoToStringRetorna uma string que representa o objeto atual. (Herdado de Object.)
Método públicoWrite(Byte[])Grava os dados especificados para esse fluxo.
Método públicoWrite(Byte[], Int32, Int32)Escreva o número especificado de Bytes no fluxo subjacente usando o buffer e o deslocamento especificados. (Substitui Stream.Write(Byte[], Int32, Int32).)
Método públicoWriteAsync(Byte[], Int32, Int32)De forma assíncrona grava uma sequência de bytes no fluxo atual e avança a posição atual dentro do fluxo de acordo com o número de bytes gravados. (Herdado de Stream.)
Método públicoWriteAsync(Byte[], Int32, Int32, CancellationToken) Grava de forma assíncrona uma sequência de bytes no fluxo atual, avança a posição atual desse fluxo pelo número de bytes gravados, e monitora as solicitações de cancelamento. (Herdado de Stream.)
Método públicoWriteByteGrava um byte à posição atual no fluxo e avança a posição dentro do fluxo por um byte. (Herdado de Stream.)
Superior

Os protocolos SSL ajudam a fornecer secreta e a integridade que realizam a existência de mensagens passadas usando SslStream. Uma conexão SSL, como aquela fornecida por SslStream, deve ser usada para comunicar informações sigilosas entre um cliente e um servidor. Usar SslStream ajuda a evitar qualquer um de leitura e violar informações quando ele estiver em trânsito na rede.

Uma instância de SslStream passar dados usando um fluxo que você forneça ao criar SslStream. Quando você fornece esse fluxo subjacente, você tem a opção para especificar fechar SslStream também fecha o fluxo subjacente. Normalmente, a classe de SslStream é usada com as classes de TcpClient e de TcpListener . O método de GetStream fornece NetworkStream adequado para uso com a classe de SslStream .

Após criar SslStream, o servidor e opcionalmente, o cliente deve ser autenticado. O servidor deve fornecer um certificado X509 que estabelece a prova de sua identidade e pode solicitar que o cliente também faz isso. A autenticação deve ser executada antes de passar informações usando SslStream. Os clientes iniciam a autenticação usando os métodos síncronos de AuthenticateAsClient , que bloco até que a autenticação seja concluído, ou os métodos assíncronos de BeginAuthenticateAsClient , que não bloco a espera de autenticação para concluir. Servidores iniciam a autenticação usando AuthenticateAsServer síncrono ou métodos assíncronos de BeginAuthenticateAsServer . O cliente e o servidor devem iniciar a autenticação.

A autenticação é tratada pelo provedor do canal de SSPI. O cliente é dada a oportunidade para controlar a validação de certificado do servidor especificando um representante de RemoteCertificateValidationCallback ao criar SslStream. O servidor também pode controlar a validação fornecendo um representante de RemoteCertificateValidationCallback . O método referenciado pelo delegado inclui o certificado de parte remoto e todos os erros SSPI encontraram para validar o certificado. Observe que se o servidor especifica um representante, o método delegate é invocado independentemente do servidor solicitou autenticação de cliente. Se o servidor não solicitou autenticação do cliente, o método delegado do servidor recebe um certificado zero e uma matriz vazia de erros de certificado.

Se o servidor requer autenticação do cliente, o cliente deve especificar um ou vários certificados para autenticação. Se o cliente tem mais de um certificado, o cliente pode fornecer um representante de LocalCertificateSelectionCallback para selecione o certificado correto para o servidor. Os certificados de cliente devem ser localizadas em meu” no repositório de certificados do usuário atual “. A autenticação do cliente através de certificados não é suportada para o protocolo de Ssl2 versão 2 (SSL).

Se a autenticação falhar, você receberá AuthenticationException, e SslStream não é mais útil. Você deve fechar este objeto e remover todas as referências a ele para que ele possa ser coletado pelo coletor de lixo.

Quando o processo de autenticação, também conhecido como o handshake SSL, tiver êxito, a identidade do servidor (e opcionalmente, cliente) é estabelecida e SslStream pode ser usada pelo cliente e o servidor para trocar mensagens. Antes de enviar ou de receber informações, o cliente e o servidor devem verificar os serviços e os níveis de segurança fornecidos por SslStream para determinar se o protocolo, os algoritmos, e os pontos selecionadas atendem aos requisitos para integridade e confidencialidade. Se as configurações atuais não são suficientes, o fluxo deve ser fechado. Você pode verificar os serviços de segurança fornecidos por SslStream usando as propriedades de IsEncrypted e de IsSigned . A tabela a seguir mostra os elementos que reportam as configurações de criptografia usadas para assinar de autenticação, de criptografia e de dados.

Element

Membros

O protocolo de segurança usado para autenticar o servidor e, opcionalmente, o cliente.

A propriedade de SslProtocol e a enumeração associada de SslProtocols .

O algoritmo de troca de chaves.

A propriedade de KeyExchangeAlgorithm e a enumeração associada de ExchangeAlgorithmType .

O algoritmo de integridade de mensagem.

A propriedade de HashAlgorithm e a enumeração associada de HashAlgorithmType .

O algoritmo do segredo de mensagem.

A propriedade de CipherAlgorithm e a enumeração associada de CipherAlgorithmType .

Os pontos de algoritmos selecionados.

KeyExchangeStrength , HashStrength, e propriedades de CipherStrength .

Após uma autenticação bem-sucedida, você pode enviar dados usando Write síncrono ou métodos assíncronos de BeginWrite . Você pode receber dados usando Read síncrono ou métodos assíncronos de BeginRead .

Se você especificou a SslStream que o fluxo subjacente deve ser deixado aberto, você é responsável para fechar o fluxo quando você é feito usando o.

ObservaçãoObservação

Se o aplicativo que cria o objeto de SslStream com as credenciais de um usuário normal, o aplicativo não poderá acessar os certificados instalados no armazenamento de computador local a menos que a permissão fornecida for explicitamente o usuário faça isso.

SslStream pressupõe que um tempo limite junto com qualquer outro IOException quando um é lançada de fluxo interno será tratado como fatal pelo chamador. Reutilizando uma instância de SslStream após um tempo limite retornará o lixo. Um aplicativo se CloseSslStream e nesses casos para lançar uma exceção.

O exemplo de código a seguir demonstra a criação de TcpListener que usa a classe de SslStream para se comunicar com clientes.


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, 
                    false, SslProtocols.Tls, 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;
        } 
    }
}


O exemplo de código a seguir demonstra a criação de TcpClient que usa a classe de SslStream para se comunicar com um servidor.


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


.NET Framework

Com suporte em: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Com suporte em: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos do sistema do .NET Framework.

Quaisquer membros estático (Shared no Visual Basic) públicos deste tipo são thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft