Prevent over long nonces in ChaCha20-Poly1305
[openssl.git] / crypto / evp / e_chacha20_poly1305.c
1 /*
2  * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include "internal/cryptlib.h"
12
13 #ifndef OPENSSL_NO_CHACHA
14
15 # include <openssl/evp.h>
16 # include <openssl/objects.h>
17 # include "evp_locl.h"
18 # include "internal/evp_int.h"
19 # include "internal/chacha.h"
20
21 typedef struct {
22     union {
23         double align;   /* this ensures even sizeof(EVP_CHACHA_KEY)%8==0 */
24         unsigned int d[CHACHA_KEY_SIZE / 4];
25     } key;
26     unsigned int  counter[CHACHA_CTR_SIZE / 4];
27     unsigned char buf[CHACHA_BLK_SIZE];
28     unsigned int  partial_len;
29 } EVP_CHACHA_KEY;
30
31 #define data(ctx)   ((EVP_CHACHA_KEY *)(ctx)->cipher_data)
32
33 #define CHACHA20_POLY1305_MAX_IVLEN     12
34
35 static int chacha_init_key(EVP_CIPHER_CTX *ctx,
36                            const unsigned char user_key[CHACHA_KEY_SIZE],
37                            const unsigned char iv[CHACHA_CTR_SIZE], int enc)
38 {
39     EVP_CHACHA_KEY *key = data(ctx);
40     unsigned int i;
41
42     if (user_key)
43         for (i = 0; i < CHACHA_KEY_SIZE; i+=4) {
44             key->key.d[i/4] = CHACHA_U8TOU32(user_key+i);
45         }
46
47     if (iv)
48         for (i = 0; i < CHACHA_CTR_SIZE; i+=4) {
49             key->counter[i/4] = CHACHA_U8TOU32(iv+i);
50         }
51
52     key->partial_len = 0;
53
54     return 1;
55 }
56
57 static int chacha_cipher(EVP_CIPHER_CTX * ctx, unsigned char *out,
58                          const unsigned char *inp, size_t len)
59 {
60     EVP_CHACHA_KEY *key = data(ctx);
61     unsigned int n, rem, ctr32;
62
63     if ((n = key->partial_len)) {
64         while (len && n < CHACHA_BLK_SIZE) {
65             *out++ = *inp++ ^ key->buf[n++];
66             len--;
67         }
68         key->partial_len = n;
69
70         if (len == 0)
71             return 1;
72
73         if (n == CHACHA_BLK_SIZE) {
74             key->partial_len = 0;
75             key->counter[0]++;
76             if (key->counter[0] == 0)
77                 key->counter[1]++;
78         }
79     }
80
81     rem = (unsigned int)(len % CHACHA_BLK_SIZE);
82     len -= rem;
83     ctr32 = key->counter[0];
84     while (len >= CHACHA_BLK_SIZE) {
85         size_t blocks = len / CHACHA_BLK_SIZE;
86         /*
87          * 1<<28 is just a not-so-small yet not-so-large number...
88          * Below condition is practically never met, but it has to
89          * be checked for code correctness.
90          */
91         if (sizeof(size_t)>sizeof(unsigned int) && blocks>(1U<<28))
92             blocks = (1U<<28);
93
94         /*
95          * As ChaCha20_ctr32 operates on 32-bit counter, caller
96          * has to handle overflow. 'if' below detects the
97          * overflow, which is then handled by limiting the
98          * amount of blocks to the exact overflow point...
99          */
100         ctr32 += (unsigned int)blocks;
101         if (ctr32 < blocks) {
102             blocks -= ctr32;
103             ctr32 = 0;
104         }
105         blocks *= CHACHA_BLK_SIZE;
106         ChaCha20_ctr32(out, inp, blocks, key->key.d, key->counter);
107         len -= blocks;
108         inp += blocks;
109         out += blocks;
110
111         key->counter[0] = ctr32;
112         if (ctr32 == 0) key->counter[1]++;
113     }
114
115     if (rem) {
116         memset(key->buf, 0, sizeof(key->buf));
117         ChaCha20_ctr32(key->buf, key->buf, CHACHA_BLK_SIZE,
118                        key->key.d, key->counter);
119         for (n = 0; n < rem; n++)
120             out[n] = inp[n] ^ key->buf[n];
121         key->partial_len = rem;
122     }
123
124     return 1;
125 }
126
127 static const EVP_CIPHER chacha20 = {
128     NID_chacha20,
129     1,                      /* block_size */
130     CHACHA_KEY_SIZE,        /* key_len */
131     CHACHA_CTR_SIZE,        /* iv_len, 128-bit counter in the context */
132     EVP_CIPH_CUSTOM_IV | EVP_CIPH_ALWAYS_CALL_INIT,
133     chacha_init_key,
134     chacha_cipher,
135     NULL,
136     sizeof(EVP_CHACHA_KEY),
137     NULL,
138     NULL,
139     NULL,
140     NULL
141 };
142
143 const EVP_CIPHER *EVP_chacha20(void)
144 {
145     return &chacha20;
146 }
147
148 # ifndef OPENSSL_NO_POLY1305
149 #  include "internal/poly1305.h"
150
151 typedef struct {
152     EVP_CHACHA_KEY key;
153     unsigned int nonce[12/4];
154     unsigned char tag[POLY1305_BLOCK_SIZE];
155     unsigned char tls_aad[POLY1305_BLOCK_SIZE];
156     struct { uint64_t aad, text; } len;
157     int aad, mac_inited, tag_len, nonce_len;
158     size_t tls_payload_length;
159 } EVP_CHACHA_AEAD_CTX;
160
161 #  define NO_TLS_PAYLOAD_LENGTH ((size_t)-1)
162 #  define aead_data(ctx)        ((EVP_CHACHA_AEAD_CTX *)(ctx)->cipher_data)
163 #  define POLY1305_ctx(actx)    ((POLY1305 *)(actx + 1))
164
165 static int chacha20_poly1305_init_key(EVP_CIPHER_CTX *ctx,
166                                       const unsigned char *inkey,
167                                       const unsigned char *iv, int enc)
168 {
169     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
170
171     if (!inkey && !iv)
172         return 1;
173
174     actx->len.aad = 0;
175     actx->len.text = 0;
176     actx->aad = 0;
177     actx->mac_inited = 0;
178     actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
179
180     if (iv != NULL) {
181         unsigned char temp[CHACHA_CTR_SIZE] = { 0 };
182
183         /* pad on the left */
184         if (actx->nonce_len <= CHACHA_CTR_SIZE)
185             memcpy(temp + CHACHA_CTR_SIZE - actx->nonce_len, iv,
186                    actx->nonce_len);
187
188         chacha_init_key(ctx, inkey, temp, enc);
189
190         actx->nonce[0] = actx->key.counter[1];
191         actx->nonce[1] = actx->key.counter[2];
192         actx->nonce[2] = actx->key.counter[3];
193     } else {
194         chacha_init_key(ctx, inkey, NULL, enc);
195     }
196
197     return 1;
198 }
199
200 #  if !defined(OPENSSL_SMALL_FOOTPRINT)
201
202 #   if defined(POLY1305_ASM) && (defined(__x86_64) || defined(__x86_64__) || \
203                                  defined(_M_AMD64) || defined(_M_X64))
204 #    define XOR128_HELPERS
205 void *xor128_encrypt_n_pad(void *out, const void *inp, void *otp, size_t len);
206 void *xor128_decrypt_n_pad(void *out, const void *inp, void *otp, size_t len);
207 static const unsigned char zero[4 * CHACHA_BLK_SIZE] = { 0 };
208 #   else
209 static const unsigned char zero[2 * CHACHA_BLK_SIZE] = { 0 };
210 #   endif
211
212 static int chacha20_poly1305_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
213                                         const unsigned char *in, size_t len)
214 {
215     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
216     size_t tail, tohash_len, buf_len, plen = actx->tls_payload_length;
217     unsigned char *buf, *tohash, *ctr, storage[sizeof(zero) + 32];
218
219     if (len != plen + POLY1305_BLOCK_SIZE)
220         return -1;
221
222     buf = storage + ((0 - (size_t)storage) & 15);   /* align */
223     ctr = buf + CHACHA_BLK_SIZE;
224     tohash = buf + CHACHA_BLK_SIZE - POLY1305_BLOCK_SIZE;
225
226 #   ifdef XOR128_HELPERS
227     if (plen <= 3 * CHACHA_BLK_SIZE) {
228         actx->key.counter[0] = 0;
229         buf_len = (plen + 2 * CHACHA_BLK_SIZE - 1) & (0 - CHACHA_BLK_SIZE);
230         ChaCha20_ctr32(buf, zero, buf_len, actx->key.key.d,
231                        actx->key.counter);
232         Poly1305_Init(POLY1305_ctx(actx), buf);
233         actx->key.partial_len = 0;
234         memcpy(tohash, actx->tls_aad, POLY1305_BLOCK_SIZE);
235         tohash_len = POLY1305_BLOCK_SIZE;
236         actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
237         actx->len.text = plen;
238
239         if (plen) {
240             if (ctx->encrypt)
241                 ctr = xor128_encrypt_n_pad(out, in, ctr, plen);
242             else
243                 ctr = xor128_decrypt_n_pad(out, in, ctr, plen);
244
245             in += plen;
246             out += plen;
247             tohash_len = (size_t)(ctr - tohash);
248         }
249     }
250 #   else
251     if (plen <= CHACHA_BLK_SIZE) {
252         size_t i;
253
254         actx->key.counter[0] = 0;
255         ChaCha20_ctr32(buf, zero, (buf_len = 2 * CHACHA_BLK_SIZE),
256                        actx->key.key.d, actx->key.counter);
257         Poly1305_Init(POLY1305_ctx(actx), buf);
258         actx->key.partial_len = 0;
259         memcpy(tohash, actx->tls_aad, POLY1305_BLOCK_SIZE);
260         tohash_len = POLY1305_BLOCK_SIZE;
261         actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
262         actx->len.text = plen;
263
264         if (ctx->encrypt) {
265             for (i = 0; i < plen; i++) {
266                 out[i] = ctr[i] ^= in[i];
267             }
268         } else {
269             for (i = 0; i < plen; i++) {
270                 unsigned char c = in[i];
271                 out[i] = ctr[i] ^ c;
272                 ctr[i] = c;
273             }
274         }
275
276         in += i;
277         out += i;
278
279         tail = (0 - i) & (POLY1305_BLOCK_SIZE - 1);
280         memset(ctr + i, 0, tail);
281         ctr += i + tail;
282         tohash_len += i + tail;
283     }
284 #   endif
285     else {
286         actx->key.counter[0] = 0;
287         ChaCha20_ctr32(buf, zero, (buf_len = CHACHA_BLK_SIZE),
288                        actx->key.key.d, actx->key.counter);
289         Poly1305_Init(POLY1305_ctx(actx), buf);
290         actx->key.counter[0] = 1;
291         actx->key.partial_len = 0;
292         Poly1305_Update(POLY1305_ctx(actx), actx->tls_aad, POLY1305_BLOCK_SIZE);
293         tohash = ctr;
294         tohash_len = 0;
295         actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
296         actx->len.text = plen;
297
298         if (ctx->encrypt) {
299             ChaCha20_ctr32(out, in, plen, actx->key.key.d, actx->key.counter);
300             Poly1305_Update(POLY1305_ctx(actx), out, plen);
301         } else {
302             Poly1305_Update(POLY1305_ctx(actx), in, plen);
303             ChaCha20_ctr32(out, in, plen, actx->key.key.d, actx->key.counter);
304         }
305
306         in += plen;
307         out += plen;
308         tail = (0 - plen) & (POLY1305_BLOCK_SIZE - 1);
309         Poly1305_Update(POLY1305_ctx(actx), zero, tail);
310     }
311
312     {
313         const union {
314             long one;
315             char little;
316         } is_endian = { 1 };
317
318         if (is_endian.little) {
319             memcpy(ctr, (unsigned char *)&actx->len, POLY1305_BLOCK_SIZE);
320         } else {
321             ctr[0]  = (unsigned char)(actx->len.aad);
322             ctr[1]  = (unsigned char)(actx->len.aad>>8);
323             ctr[2]  = (unsigned char)(actx->len.aad>>16);
324             ctr[3]  = (unsigned char)(actx->len.aad>>24);
325             ctr[4]  = (unsigned char)(actx->len.aad>>32);
326             ctr[5]  = (unsigned char)(actx->len.aad>>40);
327             ctr[6]  = (unsigned char)(actx->len.aad>>48);
328             ctr[7]  = (unsigned char)(actx->len.aad>>56);
329
330             ctr[8]  = (unsigned char)(actx->len.text);
331             ctr[9]  = (unsigned char)(actx->len.text>>8);
332             ctr[10] = (unsigned char)(actx->len.text>>16);
333             ctr[11] = (unsigned char)(actx->len.text>>24);
334             ctr[12] = (unsigned char)(actx->len.text>>32);
335             ctr[13] = (unsigned char)(actx->len.text>>40);
336             ctr[14] = (unsigned char)(actx->len.text>>48);
337             ctr[15] = (unsigned char)(actx->len.text>>56);
338         }
339         tohash_len += POLY1305_BLOCK_SIZE;
340     }
341
342     Poly1305_Update(POLY1305_ctx(actx), tohash, tohash_len);
343     OPENSSL_cleanse(buf, buf_len);
344     Poly1305_Final(POLY1305_ctx(actx), ctx->encrypt ? actx->tag
345                                                     : tohash);
346
347     actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
348
349     if (ctx->encrypt) {
350         memcpy(out, actx->tag, POLY1305_BLOCK_SIZE);
351     } else {
352         if (CRYPTO_memcmp(tohash, in, POLY1305_BLOCK_SIZE)) {
353             memset(out - (len - POLY1305_BLOCK_SIZE), 0,
354                    len - POLY1305_BLOCK_SIZE);
355             return -1;
356         }
357     }
358
359     return len;
360 }
361 #  else
362 static const unsigned char zero[CHACHA_BLK_SIZE] = { 0 };
363 #  endif
364
365 static int chacha20_poly1305_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
366                                     const unsigned char *in, size_t len)
367 {
368     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
369     size_t rem, plen = actx->tls_payload_length;
370
371     if (!actx->mac_inited) {
372 #  if !defined(OPENSSL_SMALL_FOOTPRINT)
373         if (plen != NO_TLS_PAYLOAD_LENGTH && out != NULL)
374             return chacha20_poly1305_tls_cipher(ctx, out, in, len);
375 #  endif
376         actx->key.counter[0] = 0;
377         ChaCha20_ctr32(actx->key.buf, zero, CHACHA_BLK_SIZE,
378                        actx->key.key.d, actx->key.counter);
379         Poly1305_Init(POLY1305_ctx(actx), actx->key.buf);
380         actx->key.counter[0] = 1;
381         actx->key.partial_len = 0;
382         actx->len.aad = actx->len.text = 0;
383         actx->mac_inited = 1;
384         if (plen != NO_TLS_PAYLOAD_LENGTH) {
385             Poly1305_Update(POLY1305_ctx(actx), actx->tls_aad,
386                             EVP_AEAD_TLS1_AAD_LEN);
387             actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
388             actx->aad = 1;
389         }
390     }
391
392     if (in) {                                   /* aad or text */
393         if (out == NULL) {                      /* aad */
394             Poly1305_Update(POLY1305_ctx(actx), in, len);
395             actx->len.aad += len;
396             actx->aad = 1;
397             return len;
398         } else {                                /* plain- or ciphertext */
399             if (actx->aad) {                    /* wrap up aad */
400                 if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
401                     Poly1305_Update(POLY1305_ctx(actx), zero,
402                                     POLY1305_BLOCK_SIZE - rem);
403                 actx->aad = 0;
404             }
405
406             actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
407             if (plen == NO_TLS_PAYLOAD_LENGTH)
408                 plen = len;
409             else if (len != plen + POLY1305_BLOCK_SIZE)
410                 return -1;
411
412             if (ctx->encrypt) {                 /* plaintext */
413                 chacha_cipher(ctx, out, in, plen);
414                 Poly1305_Update(POLY1305_ctx(actx), out, plen);
415                 in += plen;
416                 out += plen;
417                 actx->len.text += plen;
418             } else {                            /* ciphertext */
419                 Poly1305_Update(POLY1305_ctx(actx), in, plen);
420                 chacha_cipher(ctx, out, in, plen);
421                 in += plen;
422                 out += plen;
423                 actx->len.text += plen;
424             }
425         }
426     }
427     if (in == NULL                              /* explicit final */
428         || plen != len) {                       /* or tls mode */
429         const union {
430             long one;
431             char little;
432         } is_endian = { 1 };
433         unsigned char temp[POLY1305_BLOCK_SIZE];
434
435         if (actx->aad) {                        /* wrap up aad */
436             if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
437                 Poly1305_Update(POLY1305_ctx(actx), zero,
438                                 POLY1305_BLOCK_SIZE - rem);
439             actx->aad = 0;
440         }
441
442         if ((rem = (size_t)actx->len.text % POLY1305_BLOCK_SIZE))
443             Poly1305_Update(POLY1305_ctx(actx), zero,
444                             POLY1305_BLOCK_SIZE - rem);
445
446         if (is_endian.little) {
447             Poly1305_Update(POLY1305_ctx(actx),
448                             (unsigned char *)&actx->len, POLY1305_BLOCK_SIZE);
449         } else {
450             temp[0]  = (unsigned char)(actx->len.aad);
451             temp[1]  = (unsigned char)(actx->len.aad>>8);
452             temp[2]  = (unsigned char)(actx->len.aad>>16);
453             temp[3]  = (unsigned char)(actx->len.aad>>24);
454             temp[4]  = (unsigned char)(actx->len.aad>>32);
455             temp[5]  = (unsigned char)(actx->len.aad>>40);
456             temp[6]  = (unsigned char)(actx->len.aad>>48);
457             temp[7]  = (unsigned char)(actx->len.aad>>56);
458
459             temp[8]  = (unsigned char)(actx->len.text);
460             temp[9]  = (unsigned char)(actx->len.text>>8);
461             temp[10] = (unsigned char)(actx->len.text>>16);
462             temp[11] = (unsigned char)(actx->len.text>>24);
463             temp[12] = (unsigned char)(actx->len.text>>32);
464             temp[13] = (unsigned char)(actx->len.text>>40);
465             temp[14] = (unsigned char)(actx->len.text>>48);
466             temp[15] = (unsigned char)(actx->len.text>>56);
467
468             Poly1305_Update(POLY1305_ctx(actx), temp, POLY1305_BLOCK_SIZE);
469         }
470         Poly1305_Final(POLY1305_ctx(actx), ctx->encrypt ? actx->tag
471                                                         : temp);
472         actx->mac_inited = 0;
473
474         if (in != NULL && len != plen) {        /* tls mode */
475             if (ctx->encrypt) {
476                 memcpy(out, actx->tag, POLY1305_BLOCK_SIZE);
477             } else {
478                 if (CRYPTO_memcmp(temp, in, POLY1305_BLOCK_SIZE)) {
479                     memset(out - plen, 0, plen);
480                     return -1;
481                 }
482             }
483         }
484         else if (!ctx->encrypt) {
485             if (CRYPTO_memcmp(temp, actx->tag, actx->tag_len))
486                 return -1;
487         }
488     }
489     return len;
490 }
491
492 static int chacha20_poly1305_cleanup(EVP_CIPHER_CTX *ctx)
493 {
494     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
495     if (actx)
496         OPENSSL_cleanse(ctx->cipher_data, sizeof(*actx) + Poly1305_ctx_size());
497     return 1;
498 }
499
500 static int chacha20_poly1305_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg,
501                                   void *ptr)
502 {
503     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
504
505     switch(type) {
506     case EVP_CTRL_INIT:
507         if (actx == NULL)
508             actx = ctx->cipher_data
509                  = OPENSSL_zalloc(sizeof(*actx) + Poly1305_ctx_size());
510         if (actx == NULL) {
511             EVPerr(EVP_F_CHACHA20_POLY1305_CTRL, EVP_R_INITIALIZATION_ERROR);
512             return 0;
513         }
514         actx->len.aad = 0;
515         actx->len.text = 0;
516         actx->aad = 0;
517         actx->mac_inited = 0;
518         actx->tag_len = 0;
519         actx->nonce_len = 12;
520         actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
521         memset(actx->tls_aad, 0, POLY1305_BLOCK_SIZE);
522         return 1;
523
524     case EVP_CTRL_COPY:
525         if (actx) {
526             EVP_CIPHER_CTX *dst = (EVP_CIPHER_CTX *)ptr;
527
528             dst->cipher_data =
529                    OPENSSL_memdup(actx, sizeof(*actx) + Poly1305_ctx_size());
530             if (dst->cipher_data == NULL) {
531                 EVPerr(EVP_F_CHACHA20_POLY1305_CTRL, EVP_R_COPY_ERROR);
532                 return 0;
533             }
534         }
535         return 1;
536
537     case EVP_CTRL_AEAD_SET_IVLEN:
538         if (arg <= 0 || arg > CHACHA20_POLY1305_MAX_IVLEN)
539             return 0;
540         actx->nonce_len = arg;
541         return 1;
542
543     case EVP_CTRL_AEAD_SET_IV_FIXED:
544         if (arg != 12)
545             return 0;
546         actx->nonce[0] = actx->key.counter[1]
547                        = CHACHA_U8TOU32((unsigned char *)ptr);
548         actx->nonce[1] = actx->key.counter[2]
549                        = CHACHA_U8TOU32((unsigned char *)ptr+4);
550         actx->nonce[2] = actx->key.counter[3]
551                        = CHACHA_U8TOU32((unsigned char *)ptr+8);
552         return 1;
553
554     case EVP_CTRL_AEAD_SET_TAG:
555         if (arg <= 0 || arg > POLY1305_BLOCK_SIZE)
556             return 0;
557         if (ptr != NULL) {
558             memcpy(actx->tag, ptr, arg);
559             actx->tag_len = arg;
560         }
561         return 1;
562
563     case EVP_CTRL_AEAD_GET_TAG:
564         if (arg <= 0 || arg > POLY1305_BLOCK_SIZE || !ctx->encrypt)
565             return 0;
566         memcpy(ptr, actx->tag, arg);
567         return 1;
568
569     case EVP_CTRL_AEAD_TLS1_AAD:
570         if (arg != EVP_AEAD_TLS1_AAD_LEN)
571             return 0;
572         {
573             unsigned int len;
574             unsigned char *aad = ptr;
575
576             memcpy(actx->tls_aad, ptr, EVP_AEAD_TLS1_AAD_LEN);
577             len = aad[EVP_AEAD_TLS1_AAD_LEN - 2] << 8 |
578                   aad[EVP_AEAD_TLS1_AAD_LEN - 1];
579             aad = actx->tls_aad;
580             if (!ctx->encrypt) {
581                 if (len < POLY1305_BLOCK_SIZE)
582                     return 0;
583                 len -= POLY1305_BLOCK_SIZE;     /* discount attached tag */
584                 aad[EVP_AEAD_TLS1_AAD_LEN - 2] = (unsigned char)(len >> 8);
585                 aad[EVP_AEAD_TLS1_AAD_LEN - 1] = (unsigned char)len;
586             }
587             actx->tls_payload_length = len;
588
589             /*
590              * merge record sequence number as per RFC7905
591              */
592             actx->key.counter[1] = actx->nonce[0];
593             actx->key.counter[2] = actx->nonce[1] ^ CHACHA_U8TOU32(aad);
594             actx->key.counter[3] = actx->nonce[2] ^ CHACHA_U8TOU32(aad+4);
595             actx->mac_inited = 0;
596
597             return POLY1305_BLOCK_SIZE;         /* tag length */
598         }
599
600     case EVP_CTRL_AEAD_SET_MAC_KEY:
601         /* no-op */
602         return 1;
603
604     default:
605         return -1;
606     }
607 }
608
609 static EVP_CIPHER chacha20_poly1305 = {
610     NID_chacha20_poly1305,
611     1,                  /* block_size */
612     CHACHA_KEY_SIZE,    /* key_len */
613     12,                 /* iv_len, 96-bit nonce in the context */
614     EVP_CIPH_FLAG_AEAD_CIPHER | EVP_CIPH_CUSTOM_IV |
615     EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT |
616     EVP_CIPH_CUSTOM_COPY | EVP_CIPH_FLAG_CUSTOM_CIPHER,
617     chacha20_poly1305_init_key,
618     chacha20_poly1305_cipher,
619     chacha20_poly1305_cleanup,
620     0,          /* 0 moves context-specific structure allocation to ctrl */
621     NULL,       /* set_asn1_parameters */
622     NULL,       /* get_asn1_parameters */
623     chacha20_poly1305_ctrl,
624     NULL        /* app_data */
625 };
626
627 const EVP_CIPHER *EVP_chacha20_poly1305(void)
628 {
629     return(&chacha20_poly1305);
630 }
631 # endif
632 #endif