SSLEngine Classe

Riferimento

Definizione

Spazio dei nomi:: Javax.Net.Ssl

Assembly:: Mono.Android.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto.

[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

Ereditarietà: Object

Object
SSLEngine

Attributi: RegisterAttribute

Commenti

Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto.

Le modalità di comunicazione sicura includono: <UL>

<Li><em>Integrity Protection</em>. SSL/TLS protegge dalla modifica dei messaggi da parte di un wiretapper attivo.

<AUTENTICAZIONE< LI><em>/em>. Nella maggior parte delle modalità, SSL/TLS fornisce l'autenticazione peer. I server vengono in genere autenticati e i client possono essere autenticati come richiesto dai server.

<RISERVATEZZA LI>em (protezione della privacy)</em>.>< Nella maggior parte delle modalità SSL/TLS crittografa i dati inviati tra client e server. Ciò protegge la riservatezza dei dati, in modo che i wiretapper passivi non visualizzino dati sensibili, ad esempio informazioni finanziarie o informazioni personali di molti tipi.

</UL>

Questi tipi di protezione vengono specificati da una "suite di crittografia", che è una combinazione di algoritmi di crittografia usati da una determinata connessione SSL. Durante il processo di negoziazione, i due endpoint devono concordare una suite di crittografia disponibile in entrambi gli ambienti. Se non esiste una suite di questo tipo in comune, non è possibile stabilire alcuna connessione SSL e non è possibile scambiare dati.

La suite di crittografia usata viene stabilita da un processo di negoziazione denominato "handshaking". L'obiettivo di questo processo è creare o ricongiurre una "sessione", che può proteggere molte connessioni nel tempo. Al termine dell'handshaking, è possibile accedere agli attributi della sessione usando il #getSession() metodo .

La SSLSocket classe fornisce molte delle stesse funzionalità di sicurezza, ma tutti i dati in ingresso e in uscita vengono automaticamente trasportati usando l'oggetto sottostante java.net.Socket Socket, che per progettazione usa un modello di blocco. Sebbene sia appropriato per molte applicazioni, questo modello non offre la scalabilità richiesta dai server di grandi dimensioni.

La principale distinzione di un SSLEngine oggetto è che opera su flussi di byte in ingresso e in uscita, indipendentemente dal meccanismo di trasporto. È responsabilità dell'utente SSLEngine disporre del trasporto di I/O affidabile al peer. Separando l'astrazione SSL/TLS dal meccanismo di trasporto di I/O, SSLEngine è possibile usare per un'ampia gamma di tipi di I/O, ad esempio java.nio.channels.spi.AbstractSelectableChannel#configureBlocking(boolean) non-blocking I/O (polling), java.nio.channels.Selector selectable non-blocking I/Ojava.net.Socket Socket e i tradizionali input/OutputStream, matrici di byte o localijava.nio.ByteBuffer ByteBuffers, modelli di I/O asincroni futuri e così via.

A livello generale, appare SSLEngine quindi:

app data

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

                              net data

I dati dell'applicazione (noti anche come testo non crittografato o testo non crittografato) sono dati prodotti o utilizzati da un'applicazione. La controparte è costituita da dati di rete, costituiti da dati handshaking e/o ciphertext (crittografati) e destinati a essere trasportati tramite un meccanismo di I/O. I dati in ingresso sono dati ricevuti dal peer e i dati in uscita sono destinati al peer.

Nel contesto di un oggetto SSLEngine, il termine "handshake data" viene preso per indicare tutti i dati scambiati per stabilire e controllare una connessione sicura. I dati handshake includono i messaggi SSL/TLS "alert", "change_cipher_spec" e "handshake".

Esistono cinque fasi distinte per un oggetto SSLEngine.

<Creazione OL><li> : l'oggetto SSLEngine è stato creato e inizializzato, ma non è ancora stato usato. Durante questa fase, un'applicazione può impostare SSLEngineimpostazioni specifiche (pacchetti di crittografia abilitati, se l'handshake SSLEngine deve essere eseguito in modalità client o server e così via). Una volta iniziata l'handshaking, tuttavia, tutte le nuove impostazioni (ad eccezione della modalità client/server, vedere di seguito) verranno usate per l'handshake successivo.

<li> Initial Handshake : l'handshake iniziale è una procedura in base alla quale i due peer scambiano parametri di comunicazione fino a quando non viene stabilita una sessione SSL. I dati dell'applicazione non possono essere inviati durante questa fase.

<li> Application Data : dopo aver stabilito i parametri di comunicazione e aver completato l'handshake, i dati dell'applicazione possono fluire attraverso .SSLEngine I messaggi dell'applicazione in uscita sono crittografati e protetti dall'integrità e i messaggi in ingresso invertono il processo.

<li> Rehandshaking: entrambi i lati possono richiedere una rinegoziazione della sessione in qualsiasi momento durante la fase dei dati dell'applicazione. I nuovi dati di handshaking possono essere mescolati tra i dati dell'applicazione. Prima di avviare la fase di rehandshake, l'applicazione può reimpostare i parametri di comunicazione SSL/TLS, ad esempio l'elenco delle librerie di crittografia abilitate e se usare l'autenticazione client, ma non può cambiare tra le modalità client/server. Come in precedenza, una volta iniziata l'handshaking, tutte le nuove SSLEngine impostazioni di configurazione non verranno usate fino al successivo handshake.

<chiusura li> : quando la connessione non è più necessaria, l'applicazione deve chiudere SSLEngine e deve inviare/ricevere eventuali messaggi rimanenti al peer prima di chiudere il meccanismo di trasporto sottostante. Una volta chiuso un motore, non è riutilizzabile: è necessario creare un nuovo SSLEngine motore. </OL> Viene SSLEngine creato chiamando SSLContext#createSSLEngine() da un oggetto inizializzato SSLContext. Tutti i parametri di configurazione devono essere impostati prima di effettuare la prima chiamata a wrap(), unwrap()o beginHandshake(). Questi metodi attivano tutti l'handshake iniziale.

I dati passano attraverso il motore chiamando #wrap(ByteBuffer, ByteBuffer) wrap() o #unwrap(ByteBuffer, ByteBuffer) unwrap() rispettivamente i dati in uscita o in ingresso. A seconda dello stato di , una wrap() chiamata può utilizzare i dati dell'applicazione dal buffer di SSLEngineorigine e può produrre dati di rete nel buffer di destinazione. I dati in uscita possono contenere dati dell'applicazione e/o dell'handshake. Una chiamata a unwrap() esaminerà il buffer di origine e potrebbe avanzare l'handshake se i dati sono informazioni di handshaking o inserire i dati dell'applicazione nel buffer di destinazione se i dati sono applicazioni. Lo stato dell'algoritmo SSL/TLS sottostante determinerà quando i dati vengono utilizzati e prodotti.

wrap() Chiama e unwrap() restituisce un oggetto SSLEngineResult che indica lo stato dell'operazione e,facoltativamente, come interagire con il motore per eseguire lo stato di avanzamento.

Produce SSLEngine /utilizza solo pacchetti SSL/TLS completi e non archivia i dati dell'applicazione internamente tra le chiamate a wrap()/unwrap(). Pertanto, l'input e l'output ByteBufferdevono essere ridimensionati in modo appropriato per contenere il record massimo che può essere prodotto. Le chiamate a SSLSession#getPacketBufferSize() e SSLSession#getApplicationBufferSize() devono essere usate per determinare le dimensioni appropriate del buffer. Le dimensioni del buffer di dati dell'applicazione in uscita in genere non sono importanti. Se le condizioni del buffer non consentono il consumo o la produzione dei dati appropriati, l'applicazione deve determinare (tramite SSLEngineResult) e correggere il problema e quindi ritentare la chiamata.

Ad esempio, unwrap() restituirà un SSLEngineResult.Status#BUFFER_OVERFLOW risultato se il motore determina che lo spazio del buffer di destinazione disponibile non è sufficiente. Le applicazioni devono chiamare SSLSession#getApplicationBufferSize() e confrontare tale valore con lo spazio disponibile nel buffer di destinazione, ampliando il buffer, se necessario. Analogamente, se unwrap() dovesse restituire un oggetto SSLEngineResult.Status#BUFFER_UNDERFLOW, l'applicazione deve chiamare SSLSession#getPacketBufferSize() per assicurarsi che il buffer di origine disponga di spazio sufficiente per contenere un record (in modo da ingrandire, se necessario) e quindi ottenere più dati in ingresso.

{@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.
              }
            }

A differenza SSLSocketdi , tutti i metodi di SSLEngine non bloccano. SSLEngine le implementazioni possono richiedere i risultati delle attività che possono richiedere un periodo di tempo prolungato per il completamento o addirittura bloccarsi. Ad esempio, potrebbe essere necessario che un TrustManager si connetta a un servizio di convalida del certificato remoto o che un KeyManager debba richiedere a un utente di determinare quale certificato usare come parte dell'autenticazione client. Inoltre, la creazione di firme crittografiche e la verifica di tali firme possono essere lente, apparentemente bloccanti.

Per qualsiasi operazione che potrebbe potenzialmente bloccarsi, verrà creata un'attività SSLEnginejava.lang.Runnable delegata. Quando SSLEngineResult indica che è necessario un risultato di un'attività delegata, l'applicazione deve chiamare #getDelegatedTask() per ottenere un'attività delegata in sospeso e chiamarne java.lang.Runnable#run() run() il metodo (possibilmente usando un thread diverso a seconda della strategia di calcolo). L'applicazione deve continuare a ottenere attività delegate fino a quando non esiste più e riprovare l'operazione originale.

Al termine di una sessione di comunicazione, le applicazioni devono chiudere correttamente il collegamento SSL/TLS. I protocolli SSL/TLS hanno messaggi handshake di chiusura e questi messaggi devono essere comunicati al peer prima di rilasciare SSLEngine e chiudere il meccanismo di trasporto sottostante. Una chiusura può essere avviata da uno di: un'eccezione SSLException, un messaggio di handshake di chiusura in ingresso o uno dei metodi close. In tutti i casi, i messaggi di handshake di chiusura vengono generati dal motore e wrap() devono essere chiamati ripetutamente fino a quando lo stato risultante SSLEngineResultnon restituisce "CLOSED" o #isOutboundDone() restituisce true. Tutti i dati ottenuti dal wrap() metodo devono essere inviati al peer.

#closeOutbound() viene usato per segnalare al motore che l'applicazione non inviano altri dati.

Un peer segnalerà la sua finalità di chiusura inviando il proprio messaggio di handshake di chiusura. Dopo che questo messaggio è stato ricevuto ed elaborato dalla SSLEnginechiamata locale unwrap() , l'applicazione può rilevare la chiusura chiamando unwrap() e cercando un SSLEngineResult con stato "CLOSED" o se #isInboundDone() restituisce true. Se per qualche motivo il peer chiude il collegamento di comunicazione senza inviare il messaggio di chiusura SSL/TLS appropriato, l'applicazione può rilevare la fine del flusso e può segnalare al motore tramite #closeInbound() che non ci saranno più messaggi in ingresso da elaborare. Alcune applicazioni potrebbero scegliere di richiedere l'arresto ordinato dei messaggi da un peer, nel qual caso possono verificare che la chiusura sia stata generata da un messaggio di handshake e non da una condizione di fine flusso.

Ci sono due gruppi di suite di crittografia che è necessario conoscere quando si gestiscono suite di crittografia:

<PACCHETTI><di crittografia UL LI<>em>supportati</em>: tutte le suite supportate dall'implementazione SSL. Questo elenco viene segnalato tramite #getSupportedCipherSuites().

<Suite di crittografia LI><em>Enabled</em> , che possono essere inferiori al set completo di suite supportate. Questo gruppo viene impostato usando il #setEnabledCipherSuites(String []) metodo e sottoposto a query usando il #getEnabledCipherSuites() metodo . Inizialmente, un set predefinito di pacchetti di crittografia verrà abilitato in un nuovo motore che rappresenta la configurazione minima suggerita. </UL>

Le impostazioni predefinite di implementazione richiedono che solo i pacchetti di crittografia che autenticano i server e forniscano la riservatezza siano abilitati per impostazione predefinita. Solo se entrambe le parti accettano esplicitamente le comunicazioni non autenticate e/o non private (non crittografate) verranno selezionate una suite di crittografia di questo tipo.

Ogni connessione SSL/TLS deve avere un client e un server, pertanto ogni endpoint deve decidere quale ruolo assumere. Questa scelta determina chi inizia il processo di handshaking e il tipo di messaggi che devono essere inviati da ogni parte. Il metodo #setUseClientMode(boolean) configura la modalità . Dopo l'avvio dell'handshaking iniziale, non SSLEngine è possibile passare dalle modalità client a quella server, anche quando si eseguono rinegoziazioni.

Le applicazioni possono scegliere di elaborare attività delegate in thread diversi. Quando viene creato un oggetto SSLEngine , l'oggetto corrente java.security.AccessControlContext viene salvato. Tutte le attività delegate future verranno elaborate usando questo contesto, ovvero tutte le decisioni di controllo di accesso verranno prese usando il contesto acquisito durante la creazione del motore.

<Note sulla< concorrenza B/B>>: esistono due problemi di concorrenza da tenere presenti:

<OL><li>I wrap() metodi e unwrap() possono essere eseguiti simultaneamente tra loro.

<li> I protocolli SSL/TLS usano pacchetti ordinati. Le applicazioni devono prestare attenzione per garantire che i pacchetti generati vengano recapitati in sequenza. Se i pacchetti arrivano non in ordine, possono verificarsi risultati imprevisti o irreversibili.

Ad esempio:

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

Poiché due thread non devono tentare di chiamare contemporaneamente lo stesso metodo ( wrap() o unwrap()) perché non esiste alcun modo per garantire l'ordinamento finale dei pacchetti. </OLO>

<h3>Configurazione predefinita per diverse versioni< di Android/h3>

SSLEngine Le istanze ottenute dal valore predefinito SSLContext sono configurate come segue:

<h4 Protocols</h4><>table><thead><tr><th>Protocol</th th<>>Supported (API Levels)</th th>><Enabled by default (API Levels)</th></tr></thead><tbody<>tr class="depreated"><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+</tdd><><>td>20+</td<>/tr tr<>><td>TLSv1.2</td td>><20+</td td>><20+</td/tr td>>><<>< TLSv1.3</Td><td>29+</td td<>>29+</td<>/tr<>/tbody></table>

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

<em NOTE</em>>: le suite di crittografia PSK sono abilitate per impostazione predefinita solo se il SSLContext tramite il quale è stato creato il motore è stato inizializzato con un oggetto PSKKeyManager.

Aggiunto nella versione 1.5.

Documentazione java per javax.net.ssl.SSLEngine.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal progetto Open Source Android e usato in base ai termini descritti nella licenza Creative Commons 2.5 Attribuzione.

Costruttori

SSLEngine()	Costruttore per un `SSLEngine` oggetto senza hint per una strategia di riutilizzo della sessione interna.
SSLEngine(IntPtr, JniHandleOwnership)	Costruttore usato durante la creazione di rappresentazioni gestite di oggetti JNI; chiamato dal runtime.
SSLEngine(String, Int32)	Costruttore per un oggetto `SSLEngine`.

Proprietà

ApplicationProtocol	Restituisce il valore del protocollo dell'applicazione più recente negoziato per questa connessione.
Class	Restituisce la classe di runtime di questo `Object`oggetto . (Ereditato da Object)
DelegatedTask	Restituisce un'attività delegato per questa istanza del motore.
EnableSessionCreation	Restituisce un valore che indica se è possibile stabilire nuove sessioni SSL da questo motore.
Handle	Handle per l'istanza di Android sottostante. (Ereditato da Object)
HandshakeApplicationProtocol	Restituisce il valore del protocollo dell'applicazione negoziato in un handshake SSL/TLS attualmente in corso.
HandshakeApplicationProtocolSelector	Recupera la funzione di callback che seleziona un valore del protocollo dell'applicazione durante un handshake SSL/TLS. -oppure- Registra una funzione di callback che seleziona un valore del protocollo dell'applicazione per un handshake SSL/TLS.
HandshakeSession	Restituisce l'oggetto `SSLSession` costruito durante un handshake SSL/TLS.
HandshakeStatus	Restituisce lo stato dell'handshake di questa istanza del motore.
IsInboundDone	Restituisce un valore che indica se non verranno accettati altri dati in ingresso dal motore.
IsOutboundDone	Restituisce un valore che indica se non verranno generati altri dati in uscita da questo motore.
JniIdentityHashCode	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
JniPeerMembers	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto.
NeedClientAuth	Restituisce un valore che indica se l'istanza del motore richiederà l'autenticazione client.
PeerHost	Restituisce il nome host del peer.
PeerPort	Restituisce il numero di porta del peer.
PeerReference	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
Session	Restituisce la sessione SSL per questa istanza del motore.
SSLParameters	Restituisce i parametri SSLParameter in vigore per questo sslEngine. -oppure- Applica SSLParameters a questo motore.
ThresholdClass	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice.
ThresholdType	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice.
UseClientMode	Restituisce un valore che indica se il motore è impostato in modalità client durante l'handshaking.
WantClientAuth	Restituisce un valore che indica se il motore richiederà l'autenticazione client.

Metodi

BeginHandshake()	Avvia l'handshaking (iniziale o rinegoziazione) in questo sslEngine.
Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
CloseInbound()	Segnala che non verranno inviati altri dati di rete in ingresso a questo `SSLEngine`oggetto .
CloseOutbound()	Segnala che in questo `SSLEngine`oggetto non verranno inviati altri dati dell'applicazione in uscita.
Dispose()	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
Dispose(Boolean)	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
GetEnabledCipherSuites()	Restituisce i nomi dei pacchetti di crittografia SSL attualmente abilitati per l'uso in questo motore.
GetEnabledProtocols()	Restituisce i nomi delle versioni del protocollo attualmente abilitate per l'uso con questo `SSLEngine`oggetto .
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
GetSupportedCipherSuites()	Restituisce i nomi delle suite di crittografia che possono essere abilitate per l'uso in questo motore.
GetSupportedProtocols()	Restituisce i nomi dei protocolli che possono essere abilitati per l'uso con questo `SSLEngine`oggetto .
JavaFinalize()	Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object)
Notify()	Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitor dell'oggetto. (Ereditato da Object)
SetEnabledCipherSuites(String[])	Imposta le suite di crittografia abilitate per l'uso in questo motore.
SetEnabledProtocols(String[])	Impostare le versioni del protocollo abilitate per l'uso in questo motore.
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
ToArray<T>()	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
ToString()	Restituisce una rappresentazione di stringa dell'oggetto. (Ereditato da Object)
UnregisterFromRuntime()	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
Unwrap(ByteBuffer, ByteBuffer)	Tenta di decodificare i dati di rete SSL/TLS in un buffer di dati dell'applicazione in testo non crittografato.
Unwrap(ByteBuffer, ByteBuffer[])	Tenta di decodificare i dati di rete SSL/TLS in una sequenza di buffer di dati dell'applicazione di testo non crittografato.
Unwrap(ByteBuffer, ByteBuffer[], Int32, Int32)	Tenta di decodificare i dati di rete SSL/TLS in una sottosequenza di buffer di dati dell'applicazione di testo non crittografato.
Wait()	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo <>una notifica</em> o <em>interrotto</em>. (Ereditato da Object)
Wait(Int64)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo>< una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)
Wait(Int64, Int32)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo>< una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)
Wrap(ByteBuffer, ByteBuffer)	Tenta di codificare un buffer di dati dell'applicazione in testo non crittografato in dati di rete SSL/TLS.
Wrap(ByteBuffer[], ByteBuffer)	Tenta di codificare byte di testo non crittografato da una sequenza di buffer di dati in dati di rete SSL/TLS.
Wrap(ByteBuffer[], Int32, Int32, ByteBuffer)	Tenta di codificare byte di testo non crittografato da una sottosequenza dei buffer di dati in dati di rete SSL/TLS.

Implementazioni dell'interfaccia esplicita

IJavaPeerable.Disposed()	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
IJavaPeerable.Finalized()	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione del tipo di tipo controllato dal runtime Android.
JavaCast<TResult>(IJavaObject)	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto.
GetJniTypeName(IJavaPeerable)	Classe che consente comunicazioni sicure tramite protocolli come SSL (Secure Sockets Layer) o IETF RFC 2246 "Transport Layer Security" (TLS), ma è indipendente dal trasporto.

Si applica a

Condividi tramite