2. cnp3-ebook
3. principles/security
4. English
5. Zen

59 ../../principles/security.rst:664
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Here, Bob simply sends a random nonce to Alice and verifies her signature. Since the random nonce and the signature could be captured by an eavesdropper, they cannot be used as a secret key to encrypt further data. However Bob could propose a secret key and send it encrypted with Alice's public key in response to the signed nonce that he received. 349/10000 · 349
60 ../../principles/security.rst:671
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The solution described above works provided that Bob and Alice know their respective public keys before communicating. Otherwise, the protocol is not secure against man-in-the-middle attackers. Consider Mallory sitting in the middle between Alice and Bob and assume that neither Alice nor Bob knows the other's public key. 322/10000 · 322
61 ../../principles/security.rst:705
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — In the above example, Alice sends her public key, (:math:`Alice_{pub}`), in her first message together with her identity. Mallory intercepts the message and replaces Alice's key with his own key, (:math:`Mallory_{pub}`). Bob replies with a nonce, `R`. Alice then signs the random nonce to prove that she knows :math:`Alice_{priv}`. Mallory discards the information and instead computes :math:`E_p(Mallory_{priv},R)`. Bob now thinks that he is discussing with Alice while Mallory sits in the middle. 498/10000 · 498
62 ../../principles/security.rst:714
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — There are situations where symmetric authentication is required. In this case, each user must perform some computation with his/her private key. A possible exchange is the following. Alice sends her certificate to Bob. Bob replies with a nonce, :math:`R1`, and provides his certificate. Alice encrypts :math:`R1` with her private key and generates a nonce, :math:`R2`. Bob verifies Alice's computation and encrypts :math:`R2` with his private key. Alice verifies the computation and both have been authenticated. 512/10000 · 512
63 ../../principles/security.rst:747
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The protocol described above works, but it takes a long time for Bob to authenticate Alice and for Alice to authenticate Bob. A faster authentication could be the following. 173/10000 · 173
64 ../../principles/security.rst:771
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Alice sends her random nonce, :math:`R2`. Bob signs :math:`R2` and sends his nonce : :math:`R1`. Alice signs :math:`R1` and both are authenticated. 147/10000 · 147
65 ../../principles/security.rst:775
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Now consider that Mallory wants to be authenticated as Alice. The above protocol has a subtle flaw that could be exploited by Mallory. This flaw can be exploited if Alice and Bob can act as both client and server. Knowing this, Mallory could operate as follows. Mallory starts an authentication with Bob faking himself as Alice. He sends a first message to Bob including Alice's identity. 388/10000 · 388
66 ../../principles/security.rst:799
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — In this exchange, Bob authenticates himself by signing the :math:`RA` nonce that was sent by Mallory. Now, to authenticate as Alice, Mallory needs to compute the signature of nonce :math:`RB` with Alice's private key. Mallory does not know Alice's key, but he could exploit the protocol to force Alice to perform the required computation. For this, Mallory can start an authentication to Alice as shown below. 409/10000 · 409
67 ../../principles/security.rst:822
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — In this example, Mallory has forced Alice to compute :math:`E_p(Alice_{priv},RB)` which is the information required to finalize the first exchange and be authenticated as Alice. This illustrates a common problem with authentication schemes when the same information can be used for different purposes. The problem comes from the fact that Alice agrees to compute her signature on a nonce chosen by Bob (and relayed by Mallory). This problem occurs if the nonce is a simple integer without any structure. If the nonce includes some structure such as some information about Alice and Bob's identities or even a single bit indicating whether the nonce was chosen by a user acting as a client (i.e. starting the authentication) or as a server, then the protocol is not vulnerable anymore. 784/10000 · 784
68 ../../principles/security.rst:837
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — To cope with some of the above mentioned problems, public-key cryptography is usually combined with certificates. A `certificate` is a data structure that includes a signature from a trusted third party. A simple explanation of the utilization of certificates is to consider that Alice and Bob both know Ted. Ted is trusted by these two users and both have stored Ted's public key : :math:`Ted_{pub}`. Since they both know Ted's key, he can issue certificates. A certificate is mainly a cryptographic link between the identity of a user and his/her public key. Such a certificate can be computed in different ways. A simple solution is for Ted to generate a file that contains the following information for each certified user : 728/10000 · 728
69 ../../principles/security.rst:849
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — his/her identity 16/10000 · 16
70 ../../principles/security.rst:850
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — his/her public key 18/10000 · 18
71 ../../principles/security.rst:851
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — a hash of the entire file signed with Ted's private key 55/10000 · 55
72 ../../principles/security.rst:853
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Then, knowing Ted's public key, anyone can verify the validity of a certificate. When a user sends his/her public key, he/she must also attach the certificate to prove the link between his/her identity and the public key. In practice, certificates are more complex than this. Certificates will often be used to authenticate the server and sometimes to authenticate the client. 376/10000 · 376
73 ../../principles/security.rst:860
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A possible protocol could then be the following. Alice sends :math:`Cert(Alice_{pub},Ted)`. Bob replies with a random nonce. 124/10000 · 124
74 ../../principles/security.rst:885
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Until now, we have only discussed the authentication problem. This is an important but not sufficient step to have a secure communication between two users through an insecure network. To securely exchange information, Alice and Bob need to both : 247/10000 · 247
75 ../../principles/security.rst:890
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — mutually authenticate each other 32/10000 · 32
76 ../../principles/security.rst:891
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — agree on a way to encrypt the messages that they will exchange 62/10000 · 62
77 ../../principles/security.rst:893
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Let us first explore how this could be realized by using public-key cryptography. We assume that Alice and Bob have both a public-private key pair and the corresponding certificates signed by a trusted third party : Ted. 220/10000 · 220
78 ../../principles/security.rst:898
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A possible protocol would be the following. Alice sends :math:`Cert(Alice_{pub},Ted)`. This certificate provides Alice's identity and her public key. Bob replies with the certificate containing his own public key : :math:`Cert(Bob_{pub},Ted)`. At this point, they both know the other public key and could use it to send encrypted messages. Alice would send :math:`E_p(Bob_{pub},M1)` and Bob would send :math:`E_p(Alice_{pub},M2)`. In practice, using public key encryption techniques to encrypt a large number of messages is inefficient because these cryptosystems require a large number of computations. It is more efficient to use secret key cryptosystems for most of the data and only use a public key cryptosystem to encrypt the random secret keys that will be used by the secret key encryption scheme. 805/10000 · 805