ChaCha20 and Poly1305 for IETF protocolsCheck Point Software Technologies Ltd.5 Hasolelim st.Tel Aviv6789735Israelynir.ietf@gmail.comGoogle Incagl@google.comInternet-Draft This document defines the ChaCha20 stream cipher, as well as the use of the Poly1305 authenticator, both as stand-alone algorithms, and as a "combined mode", or Authenticated Encryption with Additional Data (AEAD) algorithm. This document does not introduce any new crypto, but is meant to serve as a stable reference and an implementation guide. The Advanced Encryption Standard (AES - ) has become the gold standard in encryption. Its efficient design, wide implementation, and hardware support allow for high performance in many areas. On most modern platforms, AES is anywhere from 4x to 10x as fast as the previous most-used cipher, 3-key Data Encryption Standard (3DES - ), which makes it not only the best choice, but the only practical choice. The problem is that if future advances in cryptanalysis reveal a weakness in AES, users will be in an unenviable position. With the only other widely supported cipher being the much slower 3DES, it is not feasible to re-configure implementations to use 3DES. describes this issue and the need for a standby cipher in greater detail. This document defines such a standby cipher. We use ChaCha20 () with or without the Poly1305 () authenticator. These algorithms are not just fast. They are fast even in software-only C-language implementations, allowing for much quicker deployment when compared with algorithms such as AES that are significantly accelerated by hardware implementations. This document does not introduce these new algorithms. They have been defined in scientific papers by D. J. Bernstein, which are referenced by this document. The purpose of this document is to serve as a stable reference for IETF documents making use of these algorithms. These algorithms have undergone rigorous analysis. Several papers discuss the security of Salsa and ChaCha (, ).The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in . The description of the ChaCha algorithm will at various time refer to the ChaCha state as a "vector" or as a "matrix". This follows the use of these terms in DJB's paper. The matrix notation is more visually convenient, and gives a better notion as to why some rounds are called "column rounds" while others are called "diagonal rounds". Here's a diagram of how to matrices relate to vectors (using the C language convention of zero being the index origin).The elements in this vector or matrix are 32-bit unsigned integers. The algorithm name is "ChaCha". "ChaCha20" is a specific instance where 20 "rounds" (or 80 quarter rounds - see ) are used. Other variations are defined, with 8 or 12 rounds, but in this document we only describe the 20-round ChaCha, so the names "ChaCha" and "ChaCha20" will be used interchangeably. The subsections below describe the algorithms used and the AEAD construction. The basic operation of the ChaCha algorithm is the quarter round. It operates on four 32-bit unsigned integers, denoted a, b, c, and d. The operation is as follows (in C-like notation): a += b; d ^= a; d <<<= 16;c += d; b ^= c; b <<<= 12;a += b; d ^= a; d <<<= 8;c += d; b ^= c; b <<<= 7;Where "+" denotes integer addition modulo 2^32, "^" denotes a bitwise XOR, and "<<< n" denotes an n-bit left rotation (towards the high bits). For example, let's see the add, XOR and roll operations from the first line with sample numbers: b = 0x01020304 a = 0x11111111 d = 0x01234567 a = a + b = 0x11111111 + 0x01020304 = 0x12131415 d = d ^ a = 0x01234567 ^ 0x12131415 = 0x13305172 d = d<<<16 = 0x51721330 For a test vector, we will use the same numbers as in the example, adding something random for c. a = 0x11111111 b = 0x01020304 c = 0x9b8d6f43 d = 0x01234567 After running a Quarter Round on these 4 numbers, we get these: a = 0xea2a92f4 b = 0xcb1cf8ce c = 0x4581472e d = 0x5881c4bbThe ChaCha state does not have 4 integer numbers, but 16. So the quarter round operation works on only 4 of them - hence the name. Each quarter round operates on 4 pre-determined numbers in the ChaCha state. We will denote by QUATERROUND(x,y,z,w) a quarter-round operation on the numbers at indexes x, y, z, and w of the ChaCha state when viewed as a vector. For example, if we apply QUARTERROUND(1,5,9,13) to a state, this means running the quarter round operation on the elements marked with an asterisk, while leaving the others alone:Note that this run of quarter round is part of what is called a "column round". For a test vector, we will use a ChaCha state that was generated randomly: We will apply the QUARTERROUND(2,7,8,13) operation to this state. For obvious reasons, this one is part of what is called a "diagonal round": The ChaCha block function transforms a ChaCha state by running multiple quarter rounds. The inputs to ChaCha20 are: A 256-bit key, treated as a concatenation of 8 32-bit little-endian integers. A 96-bit nonce, treated as a concatenation of 3 32-bit little-endian integers. A 32-bit block count parameter, treated as a 32-bit little-endian integer. The output is 64 random-looking bytes. The ChaCha algorithm described here uses a 256-bit key. The original algorithm also specified 128-bit keys and 8- and 12-round variants, but these are out of scope for this document. In this section we describe the ChaCha block function. Note also that the original ChaCha had a 64-bit nonce and 64-bit block count. We have modified this here to be more consistent with recommendations in section 3.2 of . This limits the use of a single (key,nonce) combination to 2^32 blocks, or 256 GB, but that is enough for most uses. In cases where a single key is used by multiple senders, it is important to make sure that they don't use the same nonces. This can be assured by partitioning the nonce space so that the first 32 bits are unique per sender, while the other 64 bits come from a counter. The ChaCha20 state is initialized as follows: The first 4 words (0-3) are constants: 0x61707865, 0x3320646e, 0x79622d32, 0x6b206574. The next 8 words (4-11) are taken from the 256-bit key by reading the bytes in little-endian order, in 4-byte chunks. Word 12 is a block counter. Since each block is 64-byte, a 32-bit word is enough for 256 Gigabytes of data. Words 13-15 are a nonce, which should not be repeated for the same key. The 13th word is the first 32 bits of the input nonce taken as a little-endian integer, while the 15th word is the last 32 bits. ChaCha20 runs 20 rounds, alternating between "column" and "diagonal" rounds. Each round is 4 quarter-rounds, and they are run as follows. Quarter-rounds 1-4 are part of a "column" round, while 5-8 are part of a "diagonal" round: QUARTERROUND ( 0, 4, 8,12) QUARTERROUND ( 1, 5, 9,13) QUARTERROUND ( 2, 6,10,14) QUARTERROUND ( 3, 7,11,15) QUARTERROUND ( 0, 5,10,15) QUARTERROUND ( 1, 6,11,12) QUARTERROUND ( 2, 7, 8,13) QUARTERROUND ( 3, 4, 9,14) At the end of 20 rounds, we add the original input words to the output words, and serialize the result by sequencing the words one-by-one in little-endian order. Note: "addition" in the above paragraph is done modulo 2^32. In some machine languages this is called carryless addition on a 32-bit word. For a test vector, we will use the following inputs to the ChaCha20 block function: Key = 00:01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f:10:11:12:13:14:15:16:17:18:19:1a:1b:1c:1d:1e:1f. The key is a sequence of octets with no particular structure before we copy it into the ChaCha state. Nonce = (00:00:00:09:00:00:00:4a:00:00:00:00) Block Count = 1. After setting up the ChaCha state, it looks like this: After running 20 rounds (10 column rounds interleaved with 10 diagonal rounds), the ChaCha state looks like this: Finally we add the original state to the result (simple vector or matrix addition), giving this: After we serialize the state, we get this: ChaCha20 is a stream cipher designed by D. J. Bernstein. It is a refinement of the Salsa20 algorithm, and uses a 256-bit key. ChaCha20 successively calls the ChaCha20 block function, with the same key and nonce, and with successively increasing block counter parameters. ChaCha20 then serializes the resulting state by writing the numbers in little-endian order, creating a key-stream block. Concatenating the key-stream blocks from the successive blocks forms a key stream, which is then XOR-ed with the plaintext. Alternatively, each key-stream block can be XOR-ed with a plaintext block before proceeding to create the next block, saving some memory. There is no requirement for the plaintext to be an integral multiple of 512-bits. If there is extra keystream from the last block, it is discarded. Specific protocols MAY require that the plaintext and ciphertext have certain length. Such protocols need to specify how the plaintext is padded, and how much padding it receives. The inputs to ChaCha20 are: A 256-bit key A 32-bit initial counter. This can be set to any number, but will usually be zero or one. It makes sense to use 1 if we use the zero block for something else, such as generating a one-time authenticator key as part of an AEAD algorithm. A 96-bit nonce. In some protocols, this is known as the Initialization Vector. An arbitrary-length plaintext The output is an encrypted message of the same length. Decryption is done in the same way. The ChaCha20 block function is used to expand the key into a key stream, which is XOR-ed with the ciphertext giving back the plaintext. For a test vector, we will use the following inputs to the ChaCha20 block function: Key = 00:01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f:10:11:12:13:14:15:16:17:18:19:1a:1b:1c:1d:1e:1f. Nonce = (00:00:00:00:00:00:00:4a:00:00:00:00). Initial Counter = 1. We use the following for the plaintext. It was chosen to be long enough to require more than one block, but not so long that it would make this example cumbersome (so, less than 3 blocks): The following figure shows 4 ChaCha state matrices: First block as it is set up. Second block as it is set up. Note that these blocks are only two bits apart - only the counter in position 12 is different. Third block is the first block after the ChaCha20 block operation. Final block is the second block after the ChaCha20 block operation was applied.After that, we show the keystream. Finally, we XOR the Keystream with the plaintext, yielding the Ciphertext: Poly1305 is a one-time authenticator designed by D. J. Bernstein. Poly1305 takes a 32-byte one-time key and a message and produces a 16-byte tag. The original article () is entitled "The Poly1305-AES message-authentication code", and the MAC function there requires a 128-bit AES key, a 128-bit "additional key", and a 128-bit (non-secret) nonce. AES is used there for encrypting the nonce, so as to get a unique (and secret) 128-bit string, but as the paper states, "There is nothing special about AES here. One can replace AES with an arbitrary keyed function from an arbitrary set of nonces to 16-byte strings." Regardless of how the key is generated, the key is partitioned into two parts, called "r" and "s". The pair (r,s) should be unique, and MUST be unpredictable for each invocation (that is why it was originally obtained by encrypting a nonce), while "r" MAY be constant, but needs to be modified as follows before being used: ("r" is treated as a 16-octet little-endian number): r[3], r[7], r[11], and r[15] are required to have their top four bits clear (be smaller than 16) r[4], r[8], and r[12] are required to have their bottom two bits clear (be divisible by 4) The following sample code clamps "r" to be appropriate: The "s" should be unpredictable, but it is perfectly acceptable to generate both "r" and "s" uniquely each time. Because each of them is 128-bit, pseudo-randomly generating them (see ) is also acceptable. The inputs to Poly1305 are: A 256-bit one-time key An arbitrary length message The output is a 128-bit tag. First, the "r" value should be clamped. Next, set the constant prime "P" be 2^130-5: 3fffffffffffffffffffffffffffffffb. Also set a variable "accumulator" to zero. Next, divide the message into 16-byte blocks. The last one might be shorter:Read the block as a little-endian number.Add one bit beyond the number of octets. For a 16-byte block this is equivalent to adding 2^128 to the number. For the shorter block it can be 2^120, 2^112, or any power of two that is evenly divisible by 8, all the way down to 2^8.If the block is not 17 bytes long (the last block), pad it with zeros. This is meaningless if you're treating it them as numbers.Add this number to the accumulator.Multiply by "r"Set the accumulator to the result modulo p. To summarize: Acc = ((Acc+block)*r) % p.Finally, the value of the secret key "s" is added to the accumulator, and the 128 least significant bits are serialized in little-endian order to form the tag. For our example, we will dispense with generating the one-time key using AES, and assume that we got the following keying material: Key Material: 85:d6:be:78:57:55:6d:33:7f:44:52:fe:42:d5:06:a8:01:03:80:8a:fb:0d:b2:fd:4a:bf:f6:af:41:49:f5:1b s as an octet string: 01:03:80:8a:fb:0d:b2:fd:4a:bf:f6:af:41:49:f5:1b s as a 128-bit number: 1bf54941aff6bf4afdb20dfb8a800301 r before clamping: 85:d6:be:78:57:55:6d:33:7f:44:52:fe:42:d5:06:a8 Clamped r as a number: 806d5400e52447c036d555408bed685. For our message, we'll use a short text:Since Poly1305 works in 16-byte chunks, the 34-byte message divides into 3 blocks. In the following calculation, "Acc" denotes the accumulator and "Block" the current block:Adding s we get this number, and serialize if to get the tag: As said in , it is acceptable to generate the one-time Poly1305 pseudo-randomly. This section proposes such a method. To generate such a key pair (r,s), we will use the ChaCha20 block function described in . This assumes that we have a 256-bit session key for the MAC function, such as SK_ai and SK_ar in IKEv2 (), the integrity key in ESP and AH, or the client_write_MAC_key and server_write_MAC_key in TLS. Any document that specifies the use of Poly1305 as a MAC algorithm for some protocol must specify that 256 bits are allocated for the integrity key. The method is to call the block function with the following parameters: The 256-bit session integrity key is used as the ChaCha20 key. The block counter is set to zero. The protocol will specify a 96-bit or 64-bit nonce. This MUST be unique per invocation with the same key, so it MUST NOT be randomly generated. A counter is a good way to implement this, but other methods, such as an LFSR are also acceptable. ChaCha20 as specified here requires a 96-bit nonce. So if the provided nonce is only 64-bit, then the first 32 bits of the nonce will be set to a constant number. This will usually be zero, but for protocols with multiple senders it may be different for each sender, but should be the same for all invocations of the function with the same key by a particular sender. After running the block function, we have a 512-bit state. We take the first 256 bits or the serialized state, and use those as the one-time Poly1305 key: The first 128 bits are clamped, and form "r", while the next 128 bits become "s". The other 256 bits are discarded. Note that while many protocols have provisions for a nonce for encryption algorithms (often called Initialization Vectors, or IVs), they usually don't have such a provision for the MAC function. In that case the per-invocation nonce will have to come from somewhere else, such as a message counter. For this example, we'll set: And that output is also the 32-byte one-time key used for Poly1305. Some protocols such as IKEv2() require a Pseudo-Random Function (PRF), mostly for key derivation. In the IKEv2 definition, a PRF is a function that accepts a variable-length key and a variable-length input, and returns a fixed-length output. This section does not specify such a function. Poly-1305 is an obvious choice, because MAC functions are often used as PRFs. However, Poly-1305 prohibits using the same key twice, whereas the PRF in IKEv2 is used multiple times with the same key. Adding a nonce or a counter to Poly-1305 can solve this issue, much as we do when using this function as a MAC, but that would require changing the interface for the PRF function. Chacha20 could be used as a key-derivation function, by generating an arbitrarily long keystream. However, that is not what protocols such as IKEv2 require. For this reason, this document does not specify a PRF, and recommends that crypto suites use some other PRF such as PRF_HMAC_SHA2_256 (section 2.1.2 of ) AEAD_CHACHA20-POLY1305 is an authenticated encryption with additional data algorithm. The inputs to AEAD_CHACHA20-POLY1305 are: A 256-bit key A 96-bit nonce - different for each invocation with the same key. An arbitrary length plaintext Arbitrary length additional authenticated data (AAD) The ChaCha20 and Poly1305 primitives are combined into an AEAD that takes a 256-bit key and 64-bit IV as follows: First the 96-bit nonce is constructed by prepending a 32-bit constant value to the IV. This could be set to zero, or could be derived from keying material, or could be assigned to a sender. It is up to the specific protocol to define the source for that 32-bit value. Next, a Poly1305 one-time key is generated from the 256-bit key and nonce using the procedure described in . The ChaCha20 encryption function is called to encrypt the plaintext, using the same key and nonce, and with the initial counter set to 1. The Poly1305 function is called with the Poly1305 key calculated above, and a message constructed as a concatenation of the following: The AAD padding1 - the padding is up to 15 zero bytes, and it brings the total length so far to an integral multiple of 16. If the length of the AAD was already an integral multiple of 16 bytes, this field is zero-length. The ciphertext padding2 - the padding is up to 15 zero bytes, and it brings the total length so far to an integral multiple of 16. If the length of the ciphertext was already an integral multiple of 16 bytes, this field is zero-length. The length of the additional data in octets (as a 64-bit little-endian integer). The length of the ciphertext in octets (as a 64-bit little-endian integer). Decryption is pretty much the same thing.The output from the AEAD is twofold: A ciphertext of the same length as the plaintext. A 128-bit tag, which is the output of the Poly1305 function. A few notes about this design: The amount of encrypted data possible in a single invocation is 2^32-1 blocks of 64 bytes each, because of the size of the block counter field in the ChaCha20 block function. This gives a total of 247,877,906,880 bytes, or nearly 256 GB. This should be enough for traffic protocols such as IPsec and TLS, but may be too small for file and/or disk encryption. For such uses, we can return to the original design, reduce the nonce to 64 bits, and use the integer at position 13 as the top 32 bits of a 64-bit block counter, increasing the total message size to over a million petabytes (1,180,591,620,717,411,303,360 bytes to be exact). Despite the previous item, the ciphertext length field in the construction of the buffer on which Poly1305 runs limits the ciphertext (and hence, the plaintext) size to 2^64 bytes, or sixteen thousand petabytes (18,446,744,073,709,551,616 bytes to be exact). For a test vector, we will use the following inputs to the AEAD_CHACHA20-POLY1305 function: Each block of ChaCha20 involves 16 move operations and one increment operation for loading the state, 80 each of XOR, addition and Roll operations for the rounds, 16 more add operations and 16 XOR operations for protecting the plaintext. describes the ChaCha block function as "adding the original input words". This implies that before starting the rounds on the ChaCha state, we copy it aside, only to add it in later. This is correct, but we can save a few operations if we instead copy the state and do the work on the copy. This way, for the next block you don't need to recreate the state, but only to increment the block counter. This saves approximately 5.5% of the cycles. It is not recommended to use a generic big number library such as the one in OpenSSL for the arithmetic operations in Poly1305. Such libraries use dynamic allocation to be able to handle any-sized integer, but that flexibility comes at the expense of performance as well as side-channel security. More efficient implementations that run in constant time are available, one of them in DJB's own library, NaCl (). A constant-time but not optimal approach would be to naively implement the arithmetic operations for a 288-bit integers, because even a naive implementation will not exceed 2^288 in the multiplication of (acc+block) and r. An efficient constant-time implementation can be found in the public domain library poly1305-donna (). The ChaCha20 cipher is designed to provide 256-bit security. The Poly1305 authenticator is designed to ensure that forged messages are rejected with a probability of 1-(n/(2^102)) for a 16n-byte message, even after sending 2^64 legitimate messages, so it is SUF-CMA in the terminology of . Proving the security of either of these is beyond the scope of this document. Such proofs are available in the referenced academic papers. The most important security consideration in implementing this draft is the uniqueness of the nonce used in ChaCha20. Counters and LFSRs are both acceptable ways of generating unique nonces, as is encrypting a counter using a 64-bit cipher such as DES. Note that it is not acceptable to use a truncation of a counter encrypted with a 128-bit or 256-bit cipher, because such a truncation may repeat after a short time. The Poly1305 key MUST be unpredictable to an attacker. Randomly generating the key would fulfill this requirement, except that Poly1305 is often used in communications protocols, so the receiver should know the key. Pseudo-random number generation such as by encrypting a counter is acceptable. Using ChaCha with a secret key and a nonce is also acceptable. The algorithms presented here were designed to be easy to implement in constant time to avoid side-channel vulnerabilities. The operations used in ChaCha20 are all additions, XORs, and fixed rotations. All of these can and should be implemented in constant time. Access to offsets into the ChaCha state and the number of operations do not depend on any property of the key, eliminating the chance of information about the key leaking through the timing of cache misses. For Poly1305, the operations are addition, multiplication and modulus, all on >128-bit numbers. This can be done in constant time, but a naive implementation (such as using some generic big number library) will not be constant time. For example, if the multiplication is performed as a separate operation from the modulus, the result will some times be under 2^256 and some times be above 2^256. Implementers should be careful about timing side-channels for Poly1305 by using the appropriate implementation of these operations. There are no IANA considerations for this document. ChaCha20 and Poly1305 were invented by Daniel J. Bernstein. The AEAD construction and the method of creating the one-time poly1305 key were invented by Adam Langley. Thanks to Robert Ransom, Watson Ladd, Stefan Buhler, and kenny patterson for their helpful comments and explanations. Thanks to Niels MÃ¶ller for suggesting the more efficient AEAD construction in this document. Special thanks to Ilari Liusvaara for providing extra test vectors, helpful comments, and for being the first to attempt an implementation from this draft.Key words for use in RFCs to Indicate Requirement LevelsHarvard University1350 Mass. Ave.CambridgeMA 02138- +1 617 495 3864sob@harvard.edu
General
keywordChaCha, a variant of Salsa20The University of Illinois at ChicagoThe Poly1305-AES message-authentication codeThe University of Illinois at ChicagoAdvanced Encryption Standard (AES)National Institute of Standards and TechnologyData Encryption StandardNational Institute of Standards and TechnologySelection of Future Cryptographic StandardsCisco Systems, Inc.Cisco Systems, Inc.PorticorAuthenticated Encryption: Relations among notions and analysis of the generic composition paradigmNaCl: Networking and Cryptography libraryPoly1305-donnaAn Interface and Algorithms for Authenticated EncryptionCisco Systems, Inc.Using HMAC-SHA-256, HMAC-SHA-384, and HMAC-SHA-512 with IPsecAruba NetworksNISTInternet Key Exchange Protocol Version 2 (IKEv2)New Features of Latin Dances: Analysis of Salsa, ChaCha, and RumbaFHNW, Windisch, SwitzerlandFHNW, Windisch, SwitzerlandEPFL, Lausanne, SwitzerlandFHNW, Windisch, SwitzerlandIAIK, Graz, AustriaImproved key recovery attacks on reduced-round salsa20 and chachaInstitute of Software, Chinese Academy of Sciences, Beijing, ChinaInstitute of Information Engineering, Chinese Academy of Sciences, Beijing, ChinaInstitute of Software, Chinese Academy of Sciences, Beijing, ChinaInstitute of Software, Chinese Academy of Sciences, Beijing, China The sub-sections of this appendix contain more test vectors for the algorithms in the sub-sections of . Notice how in test vector #2 r is equal to zero. The part of the Poly1305 algorithm where the accumulator is multiplied by r means that with r equal zero, the tag will be equal to s regardless of the content of the Text. Fortunately, all the proposed methods of generating r are such that getting this particular weak key is very unlikely. Below we'll see decrypting a message. We receive a ciphertext, a nonce, and a tag. We know the key. We will check the tag, and then (assuming that it validates) decrypt the ciphertext. In this particular protocol, we'll assume that there is no padding of the plaintext.