5. Examples (Esempi)

Le figure 6, 7 e 8 illustrano scambi di esempio. Si noti che le suite di cifratura TLS che utilizzano uno scambio Diffie-Hellman che offre forward secrecy possono essere utilizzate con una chiave pubblica grezza, sebbene questo documento non mostri lo scambio di informazioni a quel livello con i successivi flussi di messaggi.

5.1. TLS Server Uses a Raw Public Key (Il server TLS utilizza una chiave pubblica grezza)

Questa sezione mostra un esempio in cui il client TLS indica la sua capacità di ricevere e convalidare una chiave pubblica grezza dal server. In questo esempio, il client è piuttosto limitato poiché non è in grado di elaborare altri tipi di certificato inviati dal server. Inoltre non ha credenziali a livello TLS che potrebbe inviare al server e quindi omette l'estensione client_certificate_type. Quindi, il client popola solo l'estensione server_certificate_type con il tipo di chiave pubblica grezza, come mostrato in (1).

Quando il server TLS riceve il client hello, elabora l'estensione. Poiché ha una chiave pubblica grezza, indica in (2) che aveva scelto di inserire la struttura SubjectPublicKeyInfo nel payload Certificate (3).

Il client utilizza questa chiave pubblica grezza nell'handshake TLS insieme a una tecnica di convalida fuori banda, come DANE, per verificarla.

  client_hello,
  server_certificate_type=(RawPublicKey) // (1)
                         ->
                         <- server_hello,
                            server_certificate_type=RawPublicKey, // (2)
                            certificate, // (3)
                            server_key_exchange,
                            server_hello_done

  client_key_exchange,
  change_cipher_spec,
  finished               ->

                         <- change_cipher_spec,
                            finished

  Application Data       <-------> Application Data

Figure 6: Example with Raw Public Key Provided by the TLS Server (Figura 6: Esempio con chiave pubblica grezza fornita dal server TLS)

5.2. TLS Client and Server Use Raw Public Keys (Client e server TLS utilizzano chiavi pubbliche grezze)

Questa sezione mostra un esempio in cui sia il client TLS che il server TLS utilizzano chiavi pubbliche grezze. Questo è uno dei casi d'uso previsti per il networking di oggetti intelligenti. Il client TLS in questo caso è un dispositivo integrato configurato con una chiave pubblica grezza per l'uso con TLS ed è anche in grado di elaborare una chiave pubblica grezza inviata dal server. Pertanto, indica queste capacità in (1). Come nell'esempio mostrato in precedenza, il server soddisfa la richiesta del client, lo indica tramite il valore RawPublicKey nel payload server_certificate_type (2) e fornisce una chiave pubblica grezza nel payload Certificate al client (vedere (3)). Il server TLS richiede l'autenticazione del client e quindi include una certificate_request (4). Il payload client_certificate_type in (5) indica che il server TLS accetta una chiave pubblica grezza. Il client TLS, che ha una chiave pubblica grezza pre-provisionata, la restituisce nel payload Certificate (6) al server.

client_hello,
client_certificate_type=(RawPublicKey) // (1)
server_certificate_type=(RawPublicKey) // (1)
                         ->
                         <-  server_hello,
                             server_certificate_type=RawPublicKey // (2)
                             certificate, // (3)
                             client_certificate_type=RawPublicKey // (5)
                             certificate_request, // (4)
                             server_key_exchange,
                             server_hello_done

certificate, // (6)
client_key_exchange,
change_cipher_spec,
finished                  ->

                         <- change_cipher_spec,
                            finished

Application Data        <------->     Application Data

Figure 7: Example with Raw Public Key provided by the TLS Server and the Client (Figura 7: Esempio con chiave pubblica grezza fornita dal server TLS e dal client)

5.3. Combined Usage of Raw Public Keys and X.509 Certificates (Uso combinato di chiavi pubbliche grezze e certificati X.509)

Questa sezione mostra un esempio che combina una chiave pubblica grezza e un certificato X.509. Il client utilizza una chiave pubblica grezza per l'autenticazione del client e il server fornisce un certificato X.509. Questo scambio inizia con il client che indica la sua capacità di elaborare un certificato X.509, un certificato OpenPGP o una chiave pubblica grezza, se fornita dal server. Preferisce una chiave pubblica grezza, poiché il valore RawPublicKey precede gli altri valori nel vettore server_certificate_type. Inoltre, il client indica di avere una chiave pubblica grezza per l'autenticazione lato client (vedere (1)). Il server sceglie di fornire il proprio certificato X.509 in (3) e indica tale scelta in (2). Per l'autenticazione del client, il server indica in (4) di aver selezionato il formato della chiave pubblica grezza e richiede un certificato al client in (5). Il client TLS fornisce una chiave pubblica grezza in (6) dopo aver ricevuto ed elaborato il messaggio server hello TLS.

client_hello,
server_certificate_type=(RawPublicKey, X.509, OpenPGP)
client_certificate_type=(RawPublicKey) // (1)
                         ->
                         <-  server_hello,
                             server_certificate_type=X.509 // (2)
                             certificate, // (3)
                             client_certificate_type=RawPublicKey // (4)
                             certificate_request, // (5)
                             server_key_exchange,
                             server_hello_done
certificate, // (6)
client_key_exchange,
change_cipher_spec,
finished                  ->

                          <- change_cipher_spec,
                             finished

Application Data        <------->     Application Data

Figure 8: Hybrid Certificate Example (Figura 8: Esempio di certificato ibrido)