SSLEngine Classe

Referência

Definição

Namespace:: Javax.Net.Ssl

Assembly:: Mono.Android.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte.

[Android.Runtime.Register("javax/net/ssl/SSLEngine", DoNotGenerateAcw=true)]
public abstract class SSLEngine : Java.Lang.Object

[<Android.Runtime.Register("javax/net/ssl/SSLEngine", DoNotGenerateAcw=true)>]
type SSLEngine = class
    inherit Object

Herança: Object

Object
SSLEngine

Atributos: RegisterAttribute

Comentários

Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte.

Os modos de comunicação seguros incluem: <UL>

<><LI em>Proteção de Integridade</em>. SSL/TLS protege contra a modificação de mensagens por um grampo ativo.

<><LI em>Autenticação</em>. Na maioria dos modos, SSL/TLS fornece autenticação peer. Os servidores geralmente são autenticados e os clientes podem ser autenticados conforme solicitado pelos servidores.

<><LI em>Confidencialidade (Proteção de Privacidade)</em>. Na maioria dos modos, SSL/TLS criptografa os dados que estão sendo enviados entre o cliente e o servidor. Isso protege a confidencialidade dos dados, para que os grampos passivos não vejam dados confidenciais, como informações financeiras ou informações pessoais de vários tipos.

</UL>

Esses tipos de proteção são especificados por um "conjunto de cifras", que é uma combinação de algoritmos criptográficos usados por uma determinada conexão SSL. Durante o processo de negociação, os dois endpoints devem concordar em um conjunto de cifras que esteja disponível em ambos os ambientes. Se não houver esse conjunto em comum, nenhuma conexão SSL poderá ser estabelecida e nenhum dado poderá ser trocado.

O conjunto de cifras usado é estabelecido por um processo de negociação chamado "handshaking". O objetivo desse processo é criar ou reingressar em uma "sessão", o que pode proteger muitas conexões ao longo do tempo. Após a conclusão do handshaking, você pode acessar os atributos da sessão usando o #getSession() método.

A SSLSocket classe fornece muito da mesma funcionalidade de segurança, mas todos os dados de entrada e saída são transportados automaticamente usando o , subjacente java.net.Socket Socketque, por design, usa um modelo de bloqueio. Embora isso seja apropriado para muitos aplicativos, esse modelo não fornece a escalabilidade exigida por servidores grandes.

A principal distinção de um SSLEngine é que ele opera em fluxos de bytes de entrada e saída, independentemente do mecanismo de transporte. É responsabilidade do SSLEngine usuário providenciar o transporte de E/S confiável para o peer. Ao separar a abstração SSL/TLS do mecanismo de transporte de E/S, o pode ser usado para uma ampla variedade de tipos de E/S, como java.nio.channels.spi.AbstractSelectableChannel#configureBlocking(boolean) non-blocking I/O (polling), java.net.Socket Socketjava.nio.channels.Selector selectable non-blocking I/Oe os tradicionais Input/OutputStreams, matrizes locais java.nio.ByteBuffer ByteBuffers ou de bytes, futuros modelos de E/S assíncronos SSLEngine e assim por diante.

Em alto nível, o SSLEngine aparece assim:

app data

                           |           ^
                           |     |     |
                           v     |     |
                      +----+-----|-----+----+
                      |          |          |
                      |       SSL|Engine    |
              wrap()  |          |          |  unwrap()
                      | OUTBOUND | INBOUND  |
                      |          |          |
                      +----+-----|-----+----+
                           |     |     ^
                           |     |     |
                           v           |

                              net data

Dados de aplicativo (também conhecidos como texto sem formatação ou texto não criptografado) são dados que são produzidos ou consumidos por um aplicativo. Sua contraparte são os dados de rede, que consistem em dados de handshaking e/ou ciphertext (criptografados) e destinados a serem transportados por meio de um mecanismo de E/S. Os dados de entrada são dados que foram recebidos do peer e os dados de saída são destinados ao peer.

(No contexto de um SSLEngine, o termo "dados de handshake" é entendido como qualquer dado trocado para estabelecer e controlar uma conexão segura. Os dados de handshake incluem as mensagens SSL/TLS "alert", "change_cipher_spec" e "handshake.")

Existem cinco fases distintas para um SSLEngine.

<><OL li> Creation - O SSLEngine foi criado e inicializado, mas ainda não foi usado. Durante essa fase, um aplicativo pode definir quaisquer SSLEngineconfigurações específicas (conjuntos de codificação habilitados, se o SSLEngine handshake deve no modo cliente ou servidor e assim por diante). Uma vez que o handshaking tenha começado, no entanto, quaisquer novas configurações (exceto o modo cliente/servidor, veja abaixo) serão usadas para o próximo handshake.

<li> Initial Handshake - O handshake inicial é um procedimento pelo qual os dois pares trocam parâmetros de comunicação até que um SSLSession seja estabelecido. Os dados do aplicativo não podem ser enviados durante essa fase.

<li> Dados do aplicativo - Uma vez que os parâmetros de comunicação tenham sido estabelecidos e o handshake esteja completo, os dados do aplicativo podem fluir através do SSLEngine. As mensagens de aplicativo de saída são criptografadas e protegidas por integridade, e as mensagens de entrada revertem o processo.

<li> Rehandshaking - Qualquer um dos lados pode solicitar uma renegociação da sessão a qualquer momento durante a fase de Dados do Aplicativo. Novos dados de handshaking podem ser misturados entre os dados do aplicativo. Antes de iniciar a fase de rehandshake, o aplicativo pode redefinir os parâmetros de comunicação SSL/TLS, como a lista de conjuntos de cifras habilitados e se deseja usar a autenticação do cliente, mas não pode alterar entre os modos cliente/servidor. Como antes, uma vez que o handshaking tenha começado, quaisquer novas SSLEngine definições de configuração não serão usadas até o próximo handshake.

<li> Closure - Quando a conexão não é mais necessária, o aplicativo deve fechar o SSLEngine e deve enviar/receber quaisquer mensagens restantes para o peer antes de fechar o mecanismo de transporte subjacente. Uma vez que um mecanismo é fechado, ele não é reutilizável: um novo SSLEngine deve ser criado. </OL> An SSLEngine é criado chamando SSLContext#createSSLEngine() a partir de um SSLContextarquivo . Quaisquer parâmetros de configuração devem ser definidos antes de fazer a primeira chamada para wrap(), unwrap()ou beginHandshake(). Todos esses métodos acionam o aperto de mão inicial.

Os dados se movem pelo mecanismo chamando #wrap(ByteBuffer, ByteBuffer) wrap() ou #unwrap(ByteBuffer, ByteBuffer) unwrap() em dados de saída ou entrada, respectivamente. Dependendo do estado do , uma wrap() chamada pode consumir dados do aplicativo do buffer de origem e pode produzir dados de rede no buffer de SSLEnginedestino. Os dados de saída podem conter dados de aplicativo e/ou handshake. Uma chamada para unwrap() examinará o buffer de origem e poderá avançar o handshake se os dados estiverem agitando informações de handshaking, ou poderá colocar dados do aplicativo no buffer de destino se os dados forem do aplicativo. O estado do algoritmo SSL/TLS subjacente determinará quando os dados serão consumidos e produzidos.

Chamadas e wrap()unwrap() retorno de um SSLEngineResult que indica o status da operação e (opcionalmente) como interagir com o mecanismo para progredir.

O SSLEngine produz/consome somente pacotes SSL/TLS completos e não armazena dados de aplicativos internamente entre chamadas para wrap()/unwrap()o . Assim, as entradas e saídas ByteBufferdevem ser dimensionadas adequadamente para manter o registro máximo que pode ser produzido. Chamadas para SSLSession#getPacketBufferSize() e SSLSession#getApplicationBufferSize() devem ser usadas para determinar os tamanhos de buffer apropriados. O tamanho do buffer de dados do aplicativo de saída geralmente não importa. Se as condições de buffer não permitirem o consumo/produção adequada de dados, o aplicativo deverá determinar (via SSLEngineResult) e corrigir o problema e, em seguida, tentar a chamada novamente.

Por exemplo, unwrap() retornará um SSLEngineResult.Status#BUFFER_OVERFLOW resultado se o mecanismo determinar que não há espaço suficiente no buffer de destino disponível. Os aplicativos devem chamar SSLSession#getApplicationBufferSize() e comparar esse valor com o espaço disponível no buffer de destino, ampliando o buffer, se necessário. Da mesma forma, se unwrap() retornar um SSLEngineResult.Status#BUFFER_UNDERFLOW, o aplicativo deve chamar SSLSession#getPacketBufferSize() para garantir que o buffer de origem tenha espaço suficiente para manter um registro (ampliando, se necessário) e, em seguida, obter mais dados de entrada.

{@code
              SSLEngineResult r = engine.unwrap(src, dst);
              switch (r.getStatus()) {
              BUFFER_OVERFLOW:
                  // Could attempt to drain the dst buffer of any already obtained
                  // data, but we'll just increase it to the size needed.
                  int appSize = engine.getSession().getApplicationBufferSize();
                  ByteBuffer b = ByteBuffer.allocate(appSize + dst.position());
                  dst.flip();
                  b.put(dst);
                  dst = b;
                  // retry the operation.
                  break;
              BUFFER_UNDERFLOW:
                  int netSize = engine.getSession().getPacketBufferSize();
                  // Resize buffer if needed.
                  if (netSize > dst.capacity()) {
                      ByteBuffer b = ByteBuffer.allocate(netSize);
                      src.flip();
                      b.put(src);
                      src = b;
                  }
                  // Obtain more inbound network data for src,
                  // then retry the operation.
                  break;
              // other cases: CLOSED, OK.
              }
            }

Ao contrário SSLSocketdo , todos os métodos de SSLEngine não são bloqueados. SSLEngine As implementações podem exigir os resultados de tarefas que podem levar um longo período de tempo para serem concluídas ou até mesmo bloqueadas. Por exemplo, um TrustManager pode precisar se conectar a um serviço de validação de certificado remoto ou um KeyManager pode precisar solicitar que um usuário determine qual certificado usar como parte da autenticação do cliente. Além disso, criar assinaturas criptográficas e verificá-las pode ser lento, aparentemente bloqueador.

Para qualquer operação que possa potencialmente bloquear, o SSLEngine criará uma java.lang.Runnable tarefa delegada. Quando SSLEngineResult indica que um resultado de tarefa delegada é necessário, o aplicativo deve chamar #getDelegatedTask() para obter uma tarefa delegada pendente e chamar seu java.lang.Runnable#run() run() método (possivelmente usando um thread diferente, dependendo da estratégia de computação). O aplicativo deve continuar obtendo tarefas delegadas até que não existam mais e tente a operação original novamente.

No final de uma sessão de comunicação, os aplicativos devem fechar corretamente o link SSL/TLS. Os protocolos SSL/TLS têm mensagens de handshake de fechamento e essas mensagens devem ser comunicadas ao peer antes de liberar e SSLEngine fechar o mecanismo de transporte subjacente. Um fechamento pode ser iniciado por um dos: um SSLException, uma mensagem de handshake de fechamento de entrada ou um dos métodos de fechamento. Em todos os casos, as mensagens de handshake de fechamento são geradas pelo mecanismo e wrap() devem ser repetidamente chamadas até que o status do resultado SSLEngineResultretorne "CLOSED" ou #isOutboundDone() retorne true. Todos os dados obtidos a wrap() partir do método devem ser enviados ao par.

#closeOutbound() é usado para sinalizar ao mecanismo que o aplicativo não enviará mais dados.

Um peer sinalizará sua intenção de fechar enviando sua própria mensagem de handshake de fechamento. Após essa mensagem ter sido recebida e processada pela chamada do unwrap() localSSLEngine, o aplicativo poderá detectar o fechamento chamando unwrap() e procurando um SSLEngineResult com status "FECHADO", ou se #isInboundDone() retornar true. Se, por algum motivo, o peer fechar o link de comunicação sem enviar a mensagem de fechamento SSL/TLS adequada, o aplicativo poderá detectar o fim do fluxo e sinalizar ao mecanismo por meio de #closeInbound() que não haverá mais mensagens de entrada para processar. Alguns aplicativos podem optar por exigir mensagens de desligamento ordenadas de um peer, caso em que eles podem verificar se o fechamento foi gerado por uma mensagem de handshake e não por uma condição de fim de fluxo.

Existem dois grupos de suítes de cifras que você precisará saber ao gerenciar suítes de cifras:

<UL><LI><em>Supported/em> cipher< suites: todas as suítes que são suportadas pela implementação SSL. Esta lista é relatada usando #getSupportedCipherSuites()o .

<><LI em>Enabled</em> cipher suites, que podem ser menores do que o conjunto completo de suítes suportadas. Esse grupo é definido usando o #setEnabledCipherSuites(String []) método e consultado usando o #getEnabledCipherSuites() método. Inicialmente, um conjunto padrão de conjuntos de codificação será habilitado em um novo mecanismo que representa a configuração mínima sugerida. </UL>

Os padrões de implementação exigem que apenas conjuntos de codificação que autenticam servidores e fornecem confidencialidade sejam habilitados por padrão. Somente se ambos os lados concordarem explicitamente com comunicações não autenticadas e/ou não privadas (não criptografadas) será selecionado tal conjunto de cifras.

Cada conexão SSL/TLS deve ter um cliente e um servidor, portanto, cada ponto de extremidade deve decidir qual função assumir. Essa escolha determina quem inicia o processo de aperto de mão, bem como que tipo de mensagens devem ser enviadas por cada parte. O método #setUseClientMode(boolean) configura o modo. Uma vez iniciado o handshaking inicial, não SSLEngine é possível alternar entre os modos cliente e servidor, mesmo ao executar renegociações.

Os aplicativos podem optar por processar tarefas delegadas em threads diferentes. Quando um SSLEngine é criado, a corrente java.security.AccessControlContext é salva. Todas as futuras tarefas delegadas serão processadas usando este contexto: ou seja, todas as decisões de controle de acesso serão tomadas usando o contexto capturado na criação do mecanismo.

<RH>

<B>Notas< de simultaneidade/B>: Há duas questões de simultaneidade a serem observadas:

<><OL li>Os wrap() métodos e unwrap() podem ser executados simultaneamente um do outro.

<li> Os protocolos SSL/TLS empregam pacotes ordenados. Os aplicativos devem tomar cuidado para garantir que os pacotes gerados sejam entregues em sequência. Se os pacotes chegarem fora de ordem, resultados inesperados ou fatais podem ocorrer.

Por exemplo:

synchronized (outboundLock) {
                             sslEngine.wrap(src, dst);
                             outboundQueue.put(dst);
                         }

Como corolário, dois threads não devem tentar chamar o mesmo método (ou wrap()unwrap()) simultaneamente, porque não há como garantir a eventual ordem de pacotes. </OL>

<h3>Configuração padrão para diferentes versões< do Android/h3>

SSLEngine As instâncias obtidas do padrão SSLContext são configuradas da seguinte maneira:

<h4 Protocolos/h4><tabela<>thead<>tr><th>Protocol</th><th>Suportado (Níveis de API)</th><>Habilitado por padrão (Níveis de API)</th<>/tr></thead><tbody<>tr class="deprecated"<>td>SSLv3</td<>td>1–<> 25</TD><TD>1– 22</td></tr<>tr<>td>TLSv1</td><td>1+</td<>td>1+</td></tr<>tr<>td>TLSv1.1</td<>td>20+</td><td>20+</td<>/tr<>tr td><>TLSv1.2</td<>td>20+</td><td>20+</td></tr<>tr><td>TLSv1.3</Td><TD 29+/TD><TD>29+</TD<>/TR></Tbody></Tabela<>>

<h4 Cipher suites/h4<>table<>thead><tr><th>Cipher suite</th><>th Supported (API Levels)</th><>th Enabled by default (API Levels)</th<>/tr></thead<>tbody<>tr class="deprecated"<>td>SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA</td><td>9-22</td<>td>9-19</td></tr><><tr class="preterido"><TD>SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA/TD<>TD>9-22</TD<>TD>9-19</TD<>/TR<>TR class="preterido"><TD>SSL_DHE_DSS_WITH_DES_CBC_SHA</TD><TD 9-22></TD<>TD 9-19<>/TD></TR<>TR Class="preterido"><TD>SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA</TD<>TD 9-22></TD TD><<>9-19</td></tr<>tr class="preterido"><td>SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA</td><td>9-22</td><td>9-19</td></tr><tr class="preterido"<>td>SSL_DHE_RSA_WITH_DES_CBC_SHA</td><td>9-22</td><td>9-19</td<>/tr<>tr class="preterido"><TD SSL_DH_anon_EXPORT_WITH_DES40_CBC_SHA/TD<>TD>9-22</TD<>TD></TD></TR><TR class="preterido"><TD>SSL_DH_anon_EXPORT_WITH_RC4_40_MD5</TD><TD 9-22></TD<>TD></TD/TR<<>> TR class="preterido"<>TD>SSL_DH_anon_WITH_3DES_EDE_CBC_SHA</TD><TD 9-22><></Td><td></td></tr<>tr class="preterido"><td>SSL_DH_anon_WITH_DES_CBC_SHA</td<>td>9-22</td<>td></td<>/tr><tr class="preterido"><td>SSL_DH_anon_WITH_RC4_128_MD5</td<>td>9-22</td><td></td></tr><tr class="deprecated"><td SSL_RSA_EXPORT_> WITH_DES40_CBC_SHA</td><td>9-22</td><td>9-19</td></tr><tr class="preterido"><td>SSL_RSA_EXPORT_WITH_RC4_40_MD5</td<>td>9-22</td<>td>9-19</td<>/tr><tr<>td>SSL_RSA_WITH_3DES_EDE_CBC_SHA</td<>td>9+/td><td>9-19<</Td></tr>tr class="preterido"><td>SSL_RSA_WITH_DES_CBC_SHA</td<>td>9-22</td<>td>9-19</td<>/tr<>tr class="preterido"><td>SSL_RSA_WITH_NULL_MD5</td<>td>9-22</td<>td></td<>/tr><tr class="preterido"<>td>SSL_RSA_WITH_NULL_SHA</td><<>TD 9-22</TD<>TD></TD<>/TR><TR class="preterido"><TD>SSL_RSA_WITH_RC4_128_MD5</TD<>TD>9-25</TD<>TD>9-19</TD<>/TR><TR Class="preterido"<>TD>SSL_RSA_WITH_RC4_128_SHA</TD<>TD 9-25<>/TD><TD>9-23</TD></TR><Tr><TD>TLS_AES_128_GCM_SHA256/TD<>TD>29+</TD><TD>29+</TD></TR<>TR<>TD>TLS_AES_256_GCM_SHA384</TD><TD>29+</TD<>TD>29+</TD/TR<<>> TR<>TD TLS_CHACHA20_POLY1305_SHA256></TD<>TD>29+</TD<>TD>29+</TD><</Tr><tr class="preterido">td>TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA</td><td>1-8</td><td>1-8</td<>/tr<>tr class="preterido"<>td>TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA</td<>td>1-8</td><td>1-8</td<>/tr<>tr class="preterido"><td TLS_DHE_DSS_WITH_AES_128_>< CBC_SHA</td><td>9-22</td><td>9-22</td></tr><tr class="preterido"<>td>TLS_DHE_DSS_WITH_AES_128_CBC_SHA256</td<>td>20-22</td<>td></td></tr><tr class="preterido"<>td>TLS_DHE_DSS_WITH_AES_128_GCM_SHA256</td><td>20-22</td><td></Td></tr>tr class="preterido"<>td>TLS_DHE_DSS_WITH_AES_256_CBC_SHA</td><td>9-22</td><td>20-22</td></tr><tr class="preterido"><td>TLS_DHE_DSS_WITH_AES_256_CBC_SHA256</td<>td>20-22</td<>td></td<>/tr<>tr class="deprecated"><td TLS_DHE_DSS_WITH_>< AES_256_GCM_SHA384</td><td>20-22</td><td></td></tr<>tr class="preterido"><td>TLS_DHE_DSS_WITH_DES_CBC_SHA</td><td>1-8</td><td>1-8</td></tr><tr class="preterido"<>td>TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA</td><td>1-8</td><td>1-8</td></tr<>tr class="preterido"<>td>TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA</td<>td>1-8</td><td>1-8</td></tr><tr class="preterido"><td>TLS_DHE_RSA_WITH_AES_128_CBC_SHA</td><td>9-25</td><td>9-25</td<>/tr><tr class="preterido" ><td>TLS_DHE_RSA_WITH_AES_128_CBC_SHA256</td><td>20-25</td><td></td></tr<>tr class="preterido"><td>TLS_DHE_RSA_WITH_AES_128_GCM_SHA256</td<>td>20-25</td<>td>20-25</td<>/tr><tr class="preterido"<>td>TLS_DHE_RSA_WITH_AES_256_CBC_SHA</td><>TD 9-25</TD><TD>20-25</TD></TR><TR class="preterido"><TD>TLS_DHE_RSA_WITH_AES_256_CBC_SHA256</TD<>TD>20-25</TD<>TD></TD></TR><TR Class="preterido"><TD>TLS_DHE_RSA_WITH_AES_256_GCM_SHA384</TD><TD>20-25</TD<>TD>20-25</TD></tr><tr class="preterido"<>td>TLS_DHE_RSA_WITH_DES_CBC_SHA</td<>td>1-8</td><td>1-8</td></tr><tr class="preterido"<>td>TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA</td<>td>1-8</td><td></td<>/tr<>tr class="preterido"><td>TLS_DH_DSS_ WITH_3DES_EDE_CBC_SHA</td><td>1-8</td><td></td></tr<>tr class="preterido"><td>TLS_DH_DSS_WITH_DES_CBC_SHA</td><td>1-8</td<>td></td<>/tr<>tr class="preterido"<>td>TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA</td<>td>1-8</td><td></td></tr><tr class="preterido"<>td>TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA</td><td>1-8</td<>td></td<>/tr><tr class="preterido"><td>TLS_DH_RSA_WITH_DES_CBC_SHA</td<>td>1-8</td><td></td></tr><tr class="preterido"><td TLS_DH_anon_EXPORT_WITH_> DES40_CBC_SHA</td><td>1-8</td><td></td></tr><tr class="preterido"<>td>TLS_DH_anon_WITH_3DES_EDE_CBC_SHA</td<>td>1-8</td<>td></td></tr><tr class="preterido"><td>TLS_DH_anon_WITH_AES_128_CBC_SHA</td><td>9-22</td<>td></td></Tr><tr class="preterido">td>TLS_DH_anon_WITH_AES_128_CBC_SHA256</td><td>20-22</td<>td></td<>/tr><tr class="preterido"><td>TLS_DH_anon_WITH_AES_128_GCM_SHA256</td><td>20-22</td><td></td></tr<>tr class="preterido"><td>TLS_DH_anon_WITH_AES_256_CBC_SHA/<< TD TD>9-22</TD><TD></TD></TR<>TR class="preterido"><TD>TLS_DH_anon_WITH_AES_256_CBC_SHA256</TD<>TD>20-22</TD<>TD></TD<>/TR><TR Class="preterido"<>TD>TLS_DH_anon_WITH_AES_256_GCM_SHA384</TD<>TD 20-22></TD<>TD></TD/TR<>><><tr class="preterido"<>td>TLS_DH_anon_WITH_DES_CBC_SHA</td><td>1-8</td<>td></td></tr><tr class="preterido"<>td>TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA</td<>td>20-22</td><td></td<>/tr<>tr<>td>TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA</tdTD 20+</TD><TD>20+</TD<>/TR><TR class="Preterido"<>TD>TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256</TD><TD>20-28</TD><TD></TD/TR><>< TR<>TD>TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256</TD<>TD 20>+</TD<>TD>20+</TD/><><> tr tr<>td>TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA</td<>td>20+</td<>td>20+</td<>/tr><tr class="preterido"><td>TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384</td><td>20-28</td<>td></td></tr<>tr><td>TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384/<>< TD TD>20+</TD><TD>20+</TD<>/TR<>TR><TD TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256></TD<>TD>24+</TD<>TD>24+</TD></TR<>TR class="preterido"<>TD>TLS_ECDHE_ECDSA_WITH_NULL_SHA</TD<>TD>20-22</TD><TD/><>< td></tr><tr class="preterido"<>td>TLS_ECDHE_ECDSA_WITH_RC4_128_SHA</td<>td>20-25</td><td>20-23</td<>/tr><tr<>td>TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA</td><td>21+</td><td>21+</td<>/tr tr>><<Td>TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA</td><td>21+</td><td>21+</td></tr><tr<>td>TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256</td<>td>24+</td><td>24+</td<>/tr<>tr class="deprecated"<>td>TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA</tdTD 20-22</TD><TD></TD<>/TR<>TR<>TD>TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA</TD><TD>20+</TD><TD>20+</TD<>/TR<>TR Class="Preterido"<>TD>TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256</TD<>TD>20-28</TD TD><>><></Td></TR><TR><TD>TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256</TD<>TD>20+</TD<>TD>20+</TD></TR><TR<>TD>TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA</TD<>TD>20+</TD<>TD>20+</TD></TR><TR Class="Preterido"><TD TLS_> ECDHE_RSA_WITH_AES_256_CBC_SHA384</td><td>20-28</td><td></td></tr><tr><td>TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384</td><td>20+</td><td>20+</td></tr<>tr<>td>TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256</td><td>24+</td><td>24+</td></tr><tr class="preterido"<>td>TLS_ECDHE_RSA_WITH_NULL_SHA</td<>td>20-22</td<>td></td></tr><tr class="preterido"><td>TLS_ECDHE_RSA_WITH_RC4_128_SHA</td><td>20-25</td<>td>20-23</td></tr<>tr class="preterido"><td>TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA</td><td>20-22</td<>td></td></tr><tr class="preterido"<>td>TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA</td<>td>20-22</td><td></td<>/tr><tr class=" preterido">td>TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256</td><td>20-22</td><td></td></tr<>tr class="deprecated"><td>TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256</td<>td>20-22</td><td></td<>/tr><tr class="deprecated"<>td>TLS_ECDH_< ECDSA_WITH_AES_256_CBC_SHA</td><td>20-22</td><td></td></tr<>tr class="preterido"><td>TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384</td><td>20-22</td><td></td></tr<>tr class="preterido"><td>TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384</td>TD 20-22</TD<>TD></TD<>/TR<>TR class="preterido"><TD>TLS_ECDH_ECDSA_WITH_NULL_SHA</TD><TD>20-22</TD<>TD></TD></TR<>TR class="preterido"><TD>TLS_ECDH_ECDSA_WITH_RC4_128_SHA</TD<>TD 20-22<>/TD<>TD></TD <>></tr<>tr class="preterido"><td>TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA</td><td>20-22</td<>td></td></tr><tr class="preterido"<>td>TLS_ECDH_RSA_WITH_AES_128_CBC_SHA</td<>td>20-22</td><td></td<>/tr><tr class="preterido" ><td>TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256</td><td>20-22</td><td></td></tr<>tr class="preterido"<>td>TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256</td><td>20-22</td><td></td<>/tr<>tr class="preterido"><td>TLS_ECDH_RSA_WITH_AES_256_ CBC_SHA</td><td>20-22</td><td></td></tr<>tr class="preterido"><td>TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384</td<>td>20-22</td<>td></td<>/tr><tr class="preterido"<>td>TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384</td><td>20-22</Td><td></td></tr><tr class="preterido"<>td>TLS_ECDH_RSA_WITH_NULL_SHA</td><td>20-22</td<>td></td></tr><tr class="preterido"<>td>TLS_ECDH_RSA_WITH_RC4_128_SHA</td<>td>20-22</td><td></td<>/tr><tr class="preterido" ><td>TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA</td><td>20-22</td><td></td></tr<>tr class="preterido"<>td>TLS_ECDH_anon_WITH_AES_128_CBC_SHA</td><td>20-22</td><td></td<>/tr<>tr class="preterido"><td>TLS_ECDH_anon_WITH_AES_256_ CBC_SHA</td><td>20-22</td><td></td></tr><tr class="preterido"><td>TLS_ECDH_anon_WITH_NULL_SHA</td<>td>20-22</td<>td></td></tr><tr class="preterido"><td>TLS_ECDH_anon_WITH_RC4_128_SHA</td<>td>20-22</td><td></td></tr<>tr<>td>TLS_EMPTY_RENEGOTIATION_INFO_SCSV</td><td>20+</td><td>20+</td<>/tr><tr><td>TLS_FALLBACK_SCSV</td td<>>21+</td<>td></td<>/tr<>tr class="preterido"><td>TLS_NULL_WITH_NULL_NULL</td><td>1-8</td><td></td></tr<>tr class="preterido"<>td>TLS_PSK_WITH_3DES_EDE_CBC_SHA</td<>td>21-22</td><td></td></tr<>tr><td>TLS_PSK_WITH_AES_128_CBC_SHA</td<>td>21+</td><>TD 21+</TD<>/TR><TR<>TD TLS_PSK_WITH_AES_256_CBC_SHA<>/TD><TD>21+</TD<>TD>21+</TD<>/TR><TR class="preterido"><TD>TLS_PSK_WITH_RC4_128_SHA</TD<>TD 21-25<>/TD><TD></TD<>/TR TR>< class="preterido">td>TLS_RSA_EXPORT_WITH_DES40_CBC_SHA</td><td>1-8</td><td>1-8</td></tr><tr class="preterido"<>td>TLS_RSA_WITH_3DES_EDE_CBC_SHA</td><td>1-8</td<>td>1-8</td<>/tr><tr><td TLS_RSA_WITH_AES_>< 128_CBC_SHA</td><td>9+</td><td>9+</td></tr<>tr class="preterido"><td>TLS_RSA_WITH_AES_128_CBC_SHA256</td<>td>20-28</td<>td></td></tr><tr><td>TLS_RSA_WITH_AES_128_GCM_SHA256</td><td>20+</td><>TD 20+</TD<>/TR<>TR<>TD TLS_RSA_WITH_AES_256_CBC_SHA></TD><TD>9+</TD><TD>20+</TD></TR><TR Class="preterido"<>TD>TLS_RSA_WITH_AES_256_CBC_SHA256</TD<>TD>20-28</TD><TD></TD<>/TR TR><TD TLS_RSA_WITH_AES_256_GCM_SHA384/TD<>TD>20+</TD<>TD>20+</TD></TR<>TR class="preterido"<>TD>TLS_RSA_WITH_DES_CBC_SHA</TD<>TD 1-8></TD TD>1-8</TD<<>>/TR><TR class="preterido"><TD TLS_RSA_WITH_NULL_MD5><>><</Td><td>1-8</td><td></td></tr<>tr class="preterido"><td>TLS_RSA_WITH_NULL_SHA</td<>td>1-8</td<>td></td></tr<>tr class="preterido"><td>TLS_RSA_WITH_NULL_SHA256</td><td>20-22</td><td></td></tr></tbody></mesa>

<em>NOTA/<em>: Os conjuntos de codificação PSK são habilitados por padrão somente se o mecanismo através do SSLContext qual o mecanismo foi criado tiver sido inicializado com um PSKKeyManagerarquivo .

Adicionado em 1.5.

Documentação Java para javax.net.ssl.SSLEngine.

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usado de acordo com os termos descritos na Creative Commons 2.5 Attribution License.

Construtores

SSLEngine()	Construtor para um `SSLEngine` que não fornece dicas para uma estratégia de reutilização de sessão interna.
SSLEngine(IntPtr, JniHandleOwnership)	Um construtor usado ao criar representações gerenciadas de objetos JNI; chamado pelo tempo de execução.
SSLEngine(String, Int32)	Construtor para um `SSLEngine`arquivo .

Propriedades

ApplicationProtocol	Retorna o valor de protocolo de aplicativo mais recente negociado para essa conexão.
Class	Retorna a classe de tempo de execução deste `Object`. (Herdado de Object)
DelegatedTask	Retorna uma tarefa delegada para essa instância do mecanismo.
EnableSessionCreation	Retorna se novas sessões SSL podem ser estabelecidas por esse mecanismo.
Handle	O identificador para a instância subjacente do Android. (Herdado de Object)
HandshakeApplicationProtocol	Retorna o valor do protocolo de aplicativo negociado em um handshake SSL/TLS atualmente em andamento.
HandshakeApplicationProtocolSelector	Recupera a função de retorno de chamada que seleciona um valor de protocolo de aplicativo durante um handshake SSL/TLS. -ou- Registra uma função de retorno de chamada que seleciona um valor de protocolo de aplicativo para um handshake SSL/TLS.
HandshakeSession	Retorna o `SSLSession` que está sendo construído durante um handshake SSL/TLS.
HandshakeStatus	Retorna o status do handshake dessa instância do mecanismo.
IsInboundDone	Retorna se nenhum outro dado de entrada será aceito por esse mecanismo.
IsOutboundDone	Retorna se nenhum outro dado de saída será produzido por esse mecanismo.
JniIdentityHashCode	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
JniPeerMembers	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte.
NeedClientAuth	Retorna se essa instância do mecanismo exigirá autenticação de cliente.
PeerHost	Retorna o nome do host do par.
PeerPort	Retorna o número da porta do par.
PeerReference	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
Session	Retorna a sessão SSL para essa instância do mecanismo.
SSLParameters	Retorna os SSLParameters em vigor para este SSLEngine. -ou- Aplica SSLParameters a este mecanismo.
ThresholdClass	Esta API suporta a infraestrutura Mono para Android e não se destina a ser usada diretamente do seu código.
ThresholdType	Esta API suporta a infraestrutura Mono para Android e não se destina a ser usada diretamente do seu código.
UseClientMode	Retorna se esse mecanismo está definido para agir no modo cliente durante o handshaking.
WantClientAuth	Retorna se esse mecanismo solicitará autenticação do cliente.

Métodos

BeginHandshake()	Inicia o aperto de mão (inicial ou renegociação) neste SSLEngine.
Clone()	Cria e retorna uma cópia desse objeto. (Herdado de Object)
CloseInbound()	Sinaliza que não serão enviados mais dados de rede de entrada para este `SSLEngine`.
CloseOutbound()	Sinais de que não serão enviados mais dados de aplicativos de saída neste `SSLEngine`.
Dispose()	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
Dispose(Boolean)	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
Equals(Object)	Indica se algum outro objeto é "igual" a este. (Herdado de Object)
GetEnabledCipherSuites()	Retorna os nomes dos conjuntos de codificação SSL que estão atualmente habilitados para uso neste mecanismo.
GetEnabledProtocols()	Retorna os nomes das versões de protocolo que estão atualmente habilitadas para uso com este `SSLEngine`.
GetHashCode()	Retorna um valor de código hash para o objeto. (Herdado de Object)
GetSupportedCipherSuites()	Retorna os nomes dos conjuntos de codificação que podem ser habilitados para uso neste mecanismo.
GetSupportedProtocols()	Retorna os nomes dos protocolos que podem ser habilitados para uso com este `SSLEngine`.
JavaFinalize()	Chamado pelo coletor de lixo em um objeto quando a coleta de lixo determina que não há mais referências ao objeto. (Herdado de Object)
Notify()	Ativa um único thread que está aguardando no monitor deste objeto. (Herdado de Object)
NotifyAll()	Ativa todos os threads que estão aguardando no monitor deste objeto. (Herdado de Object)
SetEnabledCipherSuites(String[])	Define os conjuntos de codificação habilitados para uso neste mecanismo.
SetEnabledProtocols(String[])	Defina as versões de protocolo habilitadas para uso neste mecanismo.
SetHandle(IntPtr, JniHandleOwnership)	Define a propriedade Handle. (Herdado de Object)
ToArray<T>()	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
ToString()	Retorna uma representação de cadeia de caracteres do objeto. (Herdado de Object)
UnregisterFromRuntime()	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
Unwrap(ByteBuffer, ByteBuffer)	Tenta decodificar dados de rede SSL/TLS em um buffer de dados de aplicativo de texto sem formatação.
Unwrap(ByteBuffer, ByteBuffer[])	Tenta decodificar dados de rede SSL/TLS em uma sequência de buffers de dados de aplicativo de texto sem formatação.
Unwrap(ByteBuffer, ByteBuffer[], Int32, Int32)	Tenta decodificar dados de rede SSL/TLS em uma subsequência de buffers de dados de aplicativo de texto sem formatação.
Wait()	Faz com que o thread atual aguarde até que ele seja ativado, normalmente sendo <em notificado</em> ou <em>interrompido</em>>. (Herdado de Object)
Wait(Int64)	Faz com que o thread atual aguarde até que ele seja despertado, normalmente sendo <em>notificado</em> ou <em interrompido</em>, ou até que>uma certa quantidade de tempo real tenha decorrido. (Herdado de Object)
Wait(Int64, Int32)	Faz com que o thread atual aguarde até que ele seja despertado, normalmente sendo <em>notificado</em> ou <em interrompido</em>, ou até que>uma certa quantidade de tempo real tenha decorrido. (Herdado de Object)
Wrap(ByteBuffer, ByteBuffer)	Tenta codificar um buffer de dados de aplicativo de texto sem formatação em dados de rede SSL/TLS.
Wrap(ByteBuffer[], ByteBuffer)	Tenta codificar bytes de texto sem formatação de uma sequência de buffers de dados em dados de rede SSL/TLS.
Wrap(ByteBuffer[], Int32, Int32, ByteBuffer)	Tenta codificar bytes de texto sem formatação de uma subsequência de buffers de dados em dados de rede SSL/TLS.

Implantações explícitas de interface

IJavaPeerable.Disposed()	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
IJavaPeerable.DisposeUnlessReferenced()	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
IJavaPeerable.Finalized()	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
IJavaPeerable.JniManagedPeerState	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte. (Herdado de Object)

Métodos de Extensão

JavaCast<TResult>(IJavaObject)	Executa uma conversão de tipo verificada em tempo de execução do Android.
JavaCast<TResult>(IJavaObject)	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte.
GetJniTypeName(IJavaPeerable)	Uma classe que permite comunicações seguras usando protocolos como SSL (Secure Sockets Layer) ou IETF RFC 2246 "Transport Layer Security" (TLS), mas é independente de transporte.

Aplica-se a

Compartilhar via