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