2. cnp3-ebook
3. protocols/tls
4. English
5. Zen

46 ../../protocols/tls.rst:215
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — the ``ServerHelloDone`` indicates that the server has sent all the messages for the first phase of the handshake. 113/10000 · 113
47 ../../protocols/tls.rst:220
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — At this point, it is time to describe the TLS key exchange. TLS supports different key exchange mechanisms that can be negotiated as part of the selection of the cipher suite. We focus on two of them to highlight their differences: 231/10000 · 231
48 ../../protocols/tls.rst:225
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ``RSA``. This key exchange algorithm uses the encryption capabilities of the RSA public-key algorithm. The client has validated the server's public key thanks to the ``Certificate`` message. It then generates a (48 bytes) random number, encrypts it with the server public key and sends the encrypted number to the server in the ``ClientKeyExchange`` message. The server uses its private key to decrypt the random number. At this point, the client and the server share the same (48 bytes long) secret and use it to derive the secret keys required to encrypt and authenticate data in the second phase. With this key exchange algorithm, the server does not need to send a ``ServerKeyExchange`` message. 699/10000 · 699
49 ../../protocols/tls.rst:236
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ``DHE_RSA``. This key exchange algorithm is the Ephemeral Diffie Hellman key exchange with RSA signatures to authenticate the key exchange. It operates as a classical authenticated Diffie Hellman key exchange. If this key exchange has been selected by the server, it sends its Diffie Hellman parameters in the ``ServerKeyExchange`` message and signs them with its private key. The client then continues the key exchange and sends the results of its own computation in the ``ClientKeyExchange`` message. ``DHE_RSA`` is thus an authenticated Diffie Hellman key exchange where the initial message is sent by the server (instead of the client as in our first example but since the protocol is symmetric, this does not matter). 722/10000 · 722
50 ../../protocols/tls.rst:250
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — An important difference between ``DHE_RSA`` and ``RSA`` is their reaction against attacks. ``DHE_RSA`` is considered by many to be stronger than ``RSA`` because it supports `Perfect Forward Secrecy`. This property is important against attackers that are able to eavesdrop all the (encrypted) data sent and received by a server. Consider that Terrence is such an attacker that has stored all the packets exchanged by Bob's server during the last six months. If he manages, by any means, to obtain Bob's private key, he will be able to decrypt all the keys used to secure the TLS sessions with Bob's server during this period. With ``DHE_RSA``, a similar attack is less devastating. If Terrence knows Bob's private key, he will be able to launch a man-in-the-middle attack against future TLS sessions with Bob's server. However, he will not be able to recover the keys used for all the past sessions that he captured. 915/10000 · 915
51 ../../protocols/tls.rst:266
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Perfect Forward Secrecy 23/10000 · 23
52 ../../protocols/tls.rst:268
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Perfect Forward Secrecy (PFS) is an important property for key exchange protocols. A protocol provides PFS if its design guarantees that the keys used for former sessions will not be compromised even if the private key of the server is compromised. This is a very important property. ``DHE_RSA`` provides Perfect Forward Secrecy, but the ``RSA`` key exchange does not provide this property. In practice, ``DHE_RSA`` is costly from a computational viewpoint. Recent implementations of TLS thus prefer ``ECDHE_RSA`` or ``ECDHE_ECDSA`` when Perfect Forward Secrecy is required. 575/10000 · 575
53 ../../protocols/tls.rst:279
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — All the information required for the key exchange has now been transmitted. There are two important messages that will be sent by the client and the server to conclude the handshake and start the data transfer phase. 216/10000 · 216
54 ../../protocols/tls.rst:283
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The client sends the ``ChangeCipherSpec`` message followed by the ``Finished`` message. The ``ChangeCipherSpec`` message indicates that the client has received all the information required to generate the security keys for this TLS session. This messages can also appear later in the session to indicate a change in the encryption algorithms that are used, but this usage is outside the scope of this book. The ``Finished`` message is more important. It confirms to the server that the TLS handshake has been performed correctly and that no attacker has been able to modify the data sent by the client or the server. This is the first message that is encrypted with the selected security keys. It contains a hash of all the messages that were exchanged during the handshake. 774/10000 · 774
55 ../../protocols/tls.rst:294
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The server also sends a ``ChangeCipherSpec`` message followed by a ``Finished`` message. 88/10000 · 88
56 ../../protocols/tls.rst:297
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — TLS Cipher suites 17/10000 · 17
57 ../../protocols/tls.rst:299
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A TLS cipher suite is usually represented as an ASCII string that starts with TLS and contains the acronym of the key exchange algorithm, the encryption scheme with the key size and its mode of operation and the authentication algorithm. For example, ``TLS_DHE_RSA_WITH_AES_128_GCM_SHA256`` is a TLS cipher suite that uses the ``DHE_RSA`` key exchange algorithm with 128 bits AES in GCM mode for encryption and SHA-256 for authentication. The official list of TLS cipher suites is maintained by IANA [#fianaTLS]_. The NULL acronym indicates that no algorithm has been specified. For example, ``TLS_ECDH_RSA_WITH_NULL_SHA`` is a cipher suite that does not use any encryption but still uses the ``ECDH_RSA`` key exchange and ``SHA`` for authentication. 750/10000 · 750
58 ../../protocols/tls.rst:313
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The TLS record protocol 23/10000 · 23
59 ../../protocols/tls.rst:315
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The handshake is now finished. The client and the server will exchange authenticated and encrypted records. TLS defines different formats for the records depending on the cryptographic algorithms that have been negotiated for the session. A detailed discussion of these different types of records is outside the scope of this introduction. For illustration, we briefly describe one record format. 396/10000 · 396
60 ../../protocols/tls.rst:322
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — As other security protocols, TLS uses different keys to encrypt and authenticate records. These keys are derived from the MasterSecret that is either randomly generated by the client after the ``RSA`` key exchange or derived from the Diffie Hellman parameters after the ``DH_RSA`` key exchange. The exact algorithm used to derive the keys is defined in :rfc:`5246`. 365/10000 · 365
61 ../../protocols/tls.rst:329
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A TLS record is always composed of four different fields : 58/10000 · 58
62 ../../protocols/tls.rst:331
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — a `Type` that indicates the type of record. The most frequent type is `application data` which corresponds to a record containing encrypted data. The other types are `handshake`, `change_cipher_spec` and `alert`. 212/10000 · 212
63 ../../protocols/tls.rst:335
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — a `Protocol Version` field that indicates the version of the TLS protocol used. This version is composed of two sub fields : a major and a minor version number. 160/10000 · 160
64 ../../protocols/tls.rst:338
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — a `Length` field. A TLS record cannot be longer than 16,384 bytes. 66/10000 · 66
65 ../../protocols/tls.rst:339
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — a `TLSPlainText` that contains the encrypted data 49/10000 · 49