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

27 ../../principles/security.rst:324
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — RC4 is an encryption scheme defined in the late 1980s by Ron Rivest for RSA Security. Given the speed of its software implementation, it has been included in various protocols and implementations. However, cryptographers have identified several weaknesses in this algorithm. It is now deprecated and should not be used anymore :rfc:`7465`. 339/10000 · 339
28 ../../principles/security.rst:329
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — AES or the Advanced Encryption Standard is an encryption scheme that was designed by the Belgian cryptographers Joan Daemen and Vincent Rijmen in 2001 [DR2002]_. This algorithm has been standardized by the U.S. National Institute of Standards and Technology (NIST). It is now used by a wide range of applications and various hardware and software implementations exist. Many microprocessors include special instructions that ease the implementation of AES. AES divides the message to be encrypted in blocks of 128 bits and uses keys of length 128, 192 or 256 bits. The block size and the key length are important parameters of an encryption scheme. The block size indicates the smallest message that can be encrypted and forces the sender to divide each message in blocks of the supported size. If the message is larger than an integer number of blocks, then the message must be padded before being encrypted and this padding must be removed after decryption. The key size indicates the resistance of the encryption scheme against brute force attacks, i.e. attacks where the attacker tries all possible keys to find the correct one. 1133/10000 · 1133
29 ../../principles/security.rst:354
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — AES is widely used as of this writing, but other secret key encryption schemes continue to appear. ChaCha20, proposed by D. Bernstein is now used by several internet protocols :rfc:`7539`. A detailed discussion of encryption schemes is outside the scope of this book. We will consider encryption schemes as black boxes whose operation depends on a single key. A detailed overview of several of these schemes may be found in [MVV2011]_. 435/10000 · 435
30 ../../principles/security.rst:363
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — In the 1970s, Diffie and Hellman proposed in their seminal paper [DH1976]_, a different type of encryption : `public key cryptography`. In public key cryptography, each user has two different keys : 198/10000 · 198
31 ../../principles/security.rst:367
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — a public key (:math:`K_{pub}`) that he can distribute to everyone 65/10000 · 65
32 ../../principles/security.rst:368
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — a private key (:math:`K_{priv}`) that he needs to store in a secure manner and never reveal to anyone 101/10000 · 101
33 ../../principles/security.rst:371
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — These two keys are generated together and they are linked by a complex mathematical relationship that is such that it is computationally difficult to compute :math:`K_{priv}` from :math:`K_{pub}`. 196/10000 · 196
34 ../../principles/security.rst:375
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A public key cryptographic scheme is a combination of two functions : 69/10000 · 69
35 ../../principles/security.rst:377
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — an encryption function, :math:`E_{p}`, that takes a key and a message as parameters 83/10000 · 83
36 ../../principles/security.rst:378
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — a decryption function, :math:`D_{p}`, that takes a key and a message as parameters 82/10000 · 82
37 ../../principles/security.rst:380
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The public key is used to encrypt a message so that it can only be read by the intended recipient. For example, let us consider two users : Alice and Bob. Alice (resp. Bob) uses the keys :math:`A_{priv}` and :math:`A_{pub}` (resp. :math:`B_{priv}` and :math:`B_{pub}`). To send a secure message `M` to Alice, Bob computes :math:`CM=E_p(A_{pub},M)` and Alice can decrypt it by using :math:`D_p(A_{priv},CM)=D_p(A_{priv},E_p(A_{pub},M))=M`. 438/10000 · 438
38 ../../principles/security.rst:393
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Several public key encryption schemes have been proposed. Two of them have reached wide deployment : 100/10000 · 100
39 ../../principles/security.rst:396
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The Rivest Shamir Adleman (RSA) algorithm [#frsa]_ proposed in [RSA1978]_ that relies on modular exponentiation with large integers. 132/10000 · 132
40 ../../principles/security.rst:398
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The Elliptic Curve Cryptography techniques [#fecc]_ that rely on special properties of elliptic curves. 103/10000 · 103
41 ../../principles/security.rst:401
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Another interesting property of public key cryptography is its ability to compute `signatures` that can be used to authenticate a message. This capability comes from the utilization of two different keys that are linked together. If Alice wants to sign a message `M`, she can compute :math:`SM=E_p(A_{priv},M)`. Anyone who receives this signed messaged can extract its content as :math:`D_p(A_{pub},SM)=D_p(A_{pub},E_p(A_{priv},M))=M`. Everyone can use :math:`A_{pub}` to check that the message was signed by using Alice's private key (:math:`A_{priv}`). Since this key is only known by Alice, the ability to decrypt `SM` is a proof that the message was signed by Alice herself. 678/10000 · 678
42 ../../principles/security.rst:412
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — In practice, encrypting a message to sign it can be computationally costly, in particular if the message is a large file. A faster solution would be to summarize the document and only sign the summary of the document. A naive approach could be based on a checksum or CRC computed over the message. Alice would then compute :math:`C=Checksum(M)` and :math:`SC=E_p(A_{priv},C)`. She would then send both `M` and `SC` to the recipient of the message who can easily compute `C` from `SC` and verify the authenticity of the message. Unfortunately, this solution does not protect Alice and the message's recipient against a man-in-the-middle attack. If Mallory can intercept the message sent by Alice, he can easily modify Alice's message and tweak it so that it has the same checksum as the original one. The CRCs, although more complex to compute, suffer from the same problem. 873/10000 · 873
43 ../../principles/security.rst:433
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — To efficiently sign messages, Alice needs to be able to compute a summary of her message in a way that makes prohibits an attacker from generating a different message that has the same summary. `Cryptographic hash functions` were designed to solve this problem. The ideal hash function is a function that returns a different number for every possible input. In practice, it is impossible to find such a function. Cryptographic hash functions are an approximation of this perfect summarization function. They compute a summary of a given message in 128, 160, 256 bits or more. They also exhibit the `avalanche effect`. This effect indicates that a small change in the message causes a large change in the hash value. Finally hash functions are very difficult to invert. Knowing a hash value, it is computationally very difficult to find the corresponding input message. Several hash functions have been proposed by cryptographers. The most popular ones are : 957/10000 · 957
44 ../../principles/security.rst:447
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — MD5, originally proposed in :rfc:`1321`. It has been used in a wide range of applications. In 2010, attacks against MD5 were published and this hash function is now deprecated. 176/10000 · 176
45 ../../principles/security.rst:450
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — SHA-1 is a cryptographic hash function that was standardized by the NIST in 1995. It outputs 160 bits results. It is now used in a variety of network protocols. 160/10000 · 160
46 ../../principles/security.rst:453
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — SHA-2 is another family of cryptographic hash functions designed by the NIST. Different variants of SHA-2 can produce has values of 224, 256, 384 or 512 bits. 158/10000 · 158