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

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
79 ../../principles/security.rst:913
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Key exchange 12/10000 · 12
80 ../../principles/security.rst:920
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — When users want to communicate securely through a network, they need to exchange information such as the keys that will be used by an encryption algorithm even in the presence of an eavesdropper. The most widely used algorithm that allows two users to safely exchange an integer in the presence of an eavesdropper is the one proposed by Diffie and Hellman [DH1976]_. It operates with (large) integers. Two of them are public, the modulus, p, which is prime and the base, g, which must be a primitive root of p. The communicating users select a random integer, :math:`a` for Alice and :math:`b` for Bob. The exchange starts as : 627/10000 · 627
81 ../../principles/security.rst:931
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Alice selects a random integer, :math:`a` and sends :math:`A=g^{a} \mod p` to Bob 81/10000 · 81
82 ../../principles/security.rst:933
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Bob selects a random integer, :math:`b` and sends :math:`B=g^{b} \mod p` to Alice 81/10000 · 81
83 ../../principles/security.rst:935
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — From her knowledge of :math:`a` and :math:`B`, Alice can compute :math:`Secret=B^{a} \mod p= (g^{b} \mod p) ^{a} \mod p=g^{a \times b} \mod p` 142/10000 · 142
84 ../../principles/security.rst:937
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — From is knowledge of :math:`b` and :math:`A`, Bob can compute :math:`Secret=A^{b} \mod p=(g^{a} \mod p) ^{b} \mod p=g^{a \times b} \mod p` 138/10000 · 138
85 ../../principles/security.rst:940
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The security of this protocol relies on the difficulty of computing discrete logarithms, i.e. from the knowledge of :math:`A` (resp. :math:`B`), it is very difficult to extract :math:`\log(A)=\log(g^{a} \mod p)=a` (resp. :math:`\log(B)=\log(g^{b} \mod p)=b`). 259/10000 · 259
86 ../../principles/security.rst:945
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — An example of the utilization of the Diffie-Hellman key exchange is shown below. Before starting the exchange, Alice and Bob agree on a modulus (:math:`p=23`) and a base (:math:`g=5`). These two numbers are public. They are typically part of the standard that defines the protocol that uses the key exchange. 308/10000 · 308
87 ../../principles/security.rst:951
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Alice chooses a secret integer : :math:`a=8` and sends :math:`A= g^{a} \mod p= 5^{8} \mod 23=16` to Bob 103/10000 · 103
88 ../../principles/security.rst:953
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Bob chooses a secret integer : :math:`b=13` and sends :math:`B= g^{b} \mod p=5^{13} \mod 23=21` to Alice 104/10000 · 104
89 ../../principles/security.rst:955
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Alice computes :math:`S_{A}=B^{a} \mod p= 21^{8} \mod 23=3` 59/10000 · 59
90 ../../principles/security.rst:956
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Bob computes :math:`S_{B}=A^{b} \mod p= 16^{13} \mod 23=3` 58/10000 · 58