evp/e_chacha20_poly1305.c: improve performance for short TLS records.
[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 static const unsigned char zero[2 * CHACHA_BLK_SIZE] = { 0 };
200
201 static int chacha20_poly1305_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
202                                         const unsigned char *in, size_t len)
203 {
204     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
205     size_t i, tail, tohash_len, plen = actx->tls_payload_length;
206     unsigned char *buf, *tohash, *ctr, storage[2 * CHACHA_BLK_SIZE + 32];
207
208     if (len != plen + POLY1305_BLOCK_SIZE)
209         return -1;
210
211     buf = storage + ((0 - (size_t)storage) & 15);   /* align */
212     ctr = buf + CHACHA_BLK_SIZE;
213     tohash = buf + CHACHA_BLK_SIZE - POLY1305_BLOCK_SIZE;
214
215     if (plen <= CHACHA_BLK_SIZE) {
216         actx->key.counter[0] = 0;
217         ChaCha20_ctr32(buf, zero, 2 * CHACHA_BLK_SIZE, actx->key.key.d,
218                        actx->key.counter);
219         Poly1305_Init(POLY1305_ctx(actx), buf);
220         actx->key.partial_len = 0;
221         memcpy(tohash, actx->tls_aad, POLY1305_BLOCK_SIZE);
222         tohash_len = POLY1305_BLOCK_SIZE;
223         actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
224         actx->len.text = plen;
225
226         if (ctx->encrypt) {
227             for (i = 0; i < plen; i++) {
228                 out[i] = ctr[i] ^= in[i];
229             }
230         } else {
231             for (i = 0; i < plen; i++) {
232                 unsigned char c = in[i];
233                 out[i] = ctr[i] ^ c;
234                 ctr[i] = c;
235             }
236         }
237
238         in += i;
239         out += i;
240
241         tail = (0 - i) & (POLY1305_BLOCK_SIZE - 1);
242         memset(ctr + i, 0, tail);
243         ctr += i + tail;
244         tohash_len += i + tail;
245     } else {
246         actx->key.counter[0] = 0;
247         ChaCha20_ctr32(buf, zero, CHACHA_BLK_SIZE, actx->key.key.d,
248                        actx->key.counter);
249         Poly1305_Init(POLY1305_ctx(actx), buf);
250         actx->key.counter[0] = 1;
251         actx->key.partial_len = 0;
252         Poly1305_Update(POLY1305_ctx(actx), actx->tls_aad, POLY1305_BLOCK_SIZE);
253         tohash = ctr;
254         tohash_len = 0;
255         actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
256         actx->len.text = plen;
257
258         if (ctx->encrypt) {
259             ChaCha20_ctr32(out, in, plen, actx->key.key.d, actx->key.counter);
260             Poly1305_Update(POLY1305_ctx(actx), out, plen);
261         } else {
262             Poly1305_Update(POLY1305_ctx(actx), in, plen);
263             ChaCha20_ctr32(out, in, plen, actx->key.key.d, actx->key.counter);
264         }
265
266         in += plen;
267         out += plen;
268         tail = (0 - plen) & (POLY1305_BLOCK_SIZE - 1);
269         Poly1305_Update(POLY1305_ctx(actx), zero, tail);
270     }
271
272     {
273         const union {
274             long one;
275             char little;
276         } is_endian = { 1 };
277
278         if (is_endian.little) {
279             memcpy(ctr, (unsigned char *)&actx->len, POLY1305_BLOCK_SIZE);
280         } else {
281             ctr[0]  = (unsigned char)(actx->len.aad);
282             ctr[1]  = (unsigned char)(actx->len.aad>>8);
283             ctr[2]  = (unsigned char)(actx->len.aad>>16);
284             ctr[3]  = (unsigned char)(actx->len.aad>>24);
285             ctr[4]  = (unsigned char)(actx->len.aad>>32);
286             ctr[5]  = (unsigned char)(actx->len.aad>>40);
287             ctr[6]  = (unsigned char)(actx->len.aad>>48);
288             ctr[7]  = (unsigned char)(actx->len.aad>>56);
289
290             ctr[8]  = (unsigned char)(actx->len.text);
291             ctr[9]  = (unsigned char)(actx->len.text>>8);
292             ctr[10] = (unsigned char)(actx->len.text>>16);
293             ctr[11] = (unsigned char)(actx->len.text>>24);
294             ctr[12] = (unsigned char)(actx->len.text>>32);
295             ctr[13] = (unsigned char)(actx->len.text>>40);
296             ctr[14] = (unsigned char)(actx->len.text>>48);
297             ctr[15] = (unsigned char)(actx->len.text>>56);
298         }
299         tohash_len += POLY1305_BLOCK_SIZE;
300     }
301
302     Poly1305_Update(POLY1305_ctx(actx), tohash, tohash_len);
303     OPENSSL_cleanse(buf, 2 * CHACHA_BLK_SIZE);
304     Poly1305_Final(POLY1305_ctx(actx), ctx->encrypt ? actx->tag
305                                                     : tohash);
306
307     actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
308
309     if (ctx->encrypt) {
310         memcpy(out, actx->tag, POLY1305_BLOCK_SIZE);
311     } else {
312         if (CRYPTO_memcmp(tohash, in, POLY1305_BLOCK_SIZE)) {
313             memset(out - (len - POLY1305_BLOCK_SIZE), 0,
314                    len - POLY1305_BLOCK_SIZE);
315             return -1;
316         }
317     }
318
319     return len;
320 }
321 #  else
322 static const unsigned char zero[CHACHA_BLK_SIZE] = { 0 };
323 #  endif
324
325 static int chacha20_poly1305_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
326                                     const unsigned char *in, size_t len)
327 {
328     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
329     size_t rem, plen = actx->tls_payload_length;
330
331     if (!actx->mac_inited) {
332 #  if !defined(OPENSSL_SMALL_FOOTPRINT)
333         if (plen != NO_TLS_PAYLOAD_LENGTH && out != NULL)
334             return chacha20_poly1305_tls_cipher(ctx, out, in, len);
335 #  endif
336         actx->key.counter[0] = 0;
337         ChaCha20_ctr32(actx->key.buf, zero, CHACHA_BLK_SIZE,
338                        actx->key.key.d, actx->key.counter);
339         Poly1305_Init(POLY1305_ctx(actx), actx->key.buf);
340         actx->key.counter[0] = 1;
341         actx->key.partial_len = 0;
342         actx->len.aad = actx->len.text = 0;
343         actx->mac_inited = 1;
344         if (plen != NO_TLS_PAYLOAD_LENGTH) {
345             Poly1305_Update(POLY1305_ctx(actx), actx->tls_aad,
346                             EVP_AEAD_TLS1_AAD_LEN);
347             actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
348             actx->aad = 1;
349         }
350     }
351
352     if (in) {                                   /* aad or text */
353         if (out == NULL) {                      /* aad */
354             Poly1305_Update(POLY1305_ctx(actx), in, len);
355             actx->len.aad += len;
356             actx->aad = 1;
357             return len;
358         } else {                                /* plain- or ciphertext */
359             if (actx->aad) {                    /* wrap up aad */
360                 if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
361                     Poly1305_Update(POLY1305_ctx(actx), zero,
362                                     POLY1305_BLOCK_SIZE - rem);
363                 actx->aad = 0;
364             }
365
366             actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
367             if (plen == NO_TLS_PAYLOAD_LENGTH)
368                 plen = len;
369             else if (len != plen + POLY1305_BLOCK_SIZE)
370                 return -1;
371
372             if (ctx->encrypt) {                 /* plaintext */
373                 chacha_cipher(ctx, out, in, plen);
374                 Poly1305_Update(POLY1305_ctx(actx), out, plen);
375                 in += plen;
376                 out += plen;
377                 actx->len.text += plen;
378             } else {                            /* ciphertext */
379                 Poly1305_Update(POLY1305_ctx(actx), in, plen);
380                 chacha_cipher(ctx, out, in, plen);
381                 in += plen;
382                 out += plen;
383                 actx->len.text += plen;
384             }
385         }
386     }
387     if (in == NULL                              /* explicit final */
388         || plen != len) {                       /* or tls mode */
389         const union {
390             long one;
391             char little;
392         } is_endian = { 1 };
393         unsigned char temp[POLY1305_BLOCK_SIZE];
394
395         if (actx->aad) {                        /* wrap up aad */
396             if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
397                 Poly1305_Update(POLY1305_ctx(actx), zero,
398                                 POLY1305_BLOCK_SIZE - rem);
399             actx->aad = 0;
400         }
401
402         if ((rem = (size_t)actx->len.text % POLY1305_BLOCK_SIZE))
403             Poly1305_Update(POLY1305_ctx(actx), zero,
404                             POLY1305_BLOCK_SIZE - rem);
405
406         if (is_endian.little) {
407             Poly1305_Update(POLY1305_ctx(actx),
408                             (unsigned char *)&actx->len, POLY1305_BLOCK_SIZE);
409         } else {
410             temp[0]  = (unsigned char)(actx->len.aad);
411             temp[1]  = (unsigned char)(actx->len.aad>>8);
412             temp[2]  = (unsigned char)(actx->len.aad>>16);
413             temp[3]  = (unsigned char)(actx->len.aad>>24);
414             temp[4]  = (unsigned char)(actx->len.aad>>32);
415             temp[5]  = (unsigned char)(actx->len.aad>>40);
416             temp[6]  = (unsigned char)(actx->len.aad>>48);
417             temp[7]  = (unsigned char)(actx->len.aad>>56);
418
419             temp[8]  = (unsigned char)(actx->len.text);
420             temp[9]  = (unsigned char)(actx->len.text>>8);
421             temp[10] = (unsigned char)(actx->len.text>>16);
422             temp[11] = (unsigned char)(actx->len.text>>24);
423             temp[12] = (unsigned char)(actx->len.text>>32);
424             temp[13] = (unsigned char)(actx->len.text>>40);
425             temp[14] = (unsigned char)(actx->len.text>>48);
426             temp[15] = (unsigned char)(actx->len.text>>56);
427
428             Poly1305_Update(POLY1305_ctx(actx), temp, POLY1305_BLOCK_SIZE);
429         }
430         Poly1305_Final(POLY1305_ctx(actx), ctx->encrypt ? actx->tag
431                                                         : temp);
432         actx->mac_inited = 0;
433
434         if (in != NULL && len != plen) {        /* tls mode */
435             if (ctx->encrypt) {
436                 memcpy(out, actx->tag, POLY1305_BLOCK_SIZE);
437             } else {
438                 if (CRYPTO_memcmp(temp, in, POLY1305_BLOCK_SIZE)) {
439                     memset(out - plen, 0, plen);
440                     return -1;
441                 }
442             }
443         }
444         else if (!ctx->encrypt) {
445             if (CRYPTO_memcmp(temp, actx->tag, actx->tag_len))
446                 return -1;
447         }
448     }
449     return len;
450 }
451
452 static int chacha20_poly1305_cleanup(EVP_CIPHER_CTX *ctx)
453 {
454     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
455     if (actx)
456         OPENSSL_cleanse(ctx->cipher_data, sizeof(*actx) + Poly1305_ctx_size());
457     return 1;
458 }
459
460 static int chacha20_poly1305_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg,
461                                   void *ptr)
462 {
463     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
464
465     switch(type) {
466     case EVP_CTRL_INIT:
467         if (actx == NULL)
468             actx = ctx->cipher_data
469                  = OPENSSL_zalloc(sizeof(*actx) + Poly1305_ctx_size());
470         if (actx == NULL) {
471             EVPerr(EVP_F_CHACHA20_POLY1305_CTRL, EVP_R_INITIALIZATION_ERROR);
472             return 0;
473         }
474         actx->len.aad = 0;
475         actx->len.text = 0;
476         actx->aad = 0;
477         actx->mac_inited = 0;
478         actx->tag_len = 0;
479         actx->nonce_len = 12;
480         actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
481         memset(actx->tls_aad, 0, POLY1305_BLOCK_SIZE);
482         return 1;
483
484     case EVP_CTRL_COPY:
485         if (actx) {
486             EVP_CIPHER_CTX *dst = (EVP_CIPHER_CTX *)ptr;
487
488             dst->cipher_data =
489                    OPENSSL_memdup(actx, sizeof(*actx) + Poly1305_ctx_size());
490             if (dst->cipher_data == NULL) {
491                 EVPerr(EVP_F_CHACHA20_POLY1305_CTRL, EVP_R_COPY_ERROR);
492                 return 0;
493             }
494         }
495         return 1;
496
497     case EVP_CTRL_AEAD_SET_IVLEN:
498         if (arg <= 0 || arg > CHACHA_CTR_SIZE)
499             return 0;
500         actx->nonce_len = arg;
501         return 1;
502
503     case EVP_CTRL_AEAD_SET_IV_FIXED:
504         if (arg != 12)
505             return 0;
506         actx->nonce[0] = actx->key.counter[1]
507                        = CHACHA_U8TOU32((unsigned char *)ptr);
508         actx->nonce[1] = actx->key.counter[2]
509                        = CHACHA_U8TOU32((unsigned char *)ptr+4);
510         actx->nonce[2] = actx->key.counter[3]
511                        = CHACHA_U8TOU32((unsigned char *)ptr+8);
512         return 1;
513
514     case EVP_CTRL_AEAD_SET_TAG:
515         if (arg <= 0 || arg > POLY1305_BLOCK_SIZE)
516             return 0;
517         if (ptr != NULL) {
518             memcpy(actx->tag, ptr, arg);
519             actx->tag_len = arg;
520         }
521         return 1;
522
523     case EVP_CTRL_AEAD_GET_TAG:
524         if (arg <= 0 || arg > POLY1305_BLOCK_SIZE || !ctx->encrypt)
525             return 0;
526         memcpy(ptr, actx->tag, arg);
527         return 1;
528
529     case EVP_CTRL_AEAD_TLS1_AAD:
530         if (arg != EVP_AEAD_TLS1_AAD_LEN)
531             return 0;
532         {
533             unsigned int len;
534             unsigned char *aad = ptr;
535
536             memcpy(actx->tls_aad, ptr, EVP_AEAD_TLS1_AAD_LEN);
537             len = aad[EVP_AEAD_TLS1_AAD_LEN - 2] << 8 |
538                   aad[EVP_AEAD_TLS1_AAD_LEN - 1];
539             aad = actx->tls_aad;
540             if (!ctx->encrypt) {
541                 if (len < POLY1305_BLOCK_SIZE)
542                     return 0;
543                 len -= POLY1305_BLOCK_SIZE;     /* discount attached tag */
544                 aad[EVP_AEAD_TLS1_AAD_LEN - 2] = (unsigned char)(len >> 8);
545                 aad[EVP_AEAD_TLS1_AAD_LEN - 1] = (unsigned char)len;
546             }
547             actx->tls_payload_length = len;
548
549             /*
550              * merge record sequence number as per RFC7905
551              */
552             actx->key.counter[1] = actx->nonce[0];
553             actx->key.counter[2] = actx->nonce[1] ^ CHACHA_U8TOU32(aad);
554             actx->key.counter[3] = actx->nonce[2] ^ CHACHA_U8TOU32(aad+4);
555             actx->mac_inited = 0;
556
557             return POLY1305_BLOCK_SIZE;         /* tag length */
558         }
559
560     case EVP_CTRL_AEAD_SET_MAC_KEY:
561         /* no-op */
562         return 1;
563
564     default:
565         return -1;
566     }
567 }
568
569 static EVP_CIPHER chacha20_poly1305 = {
570     NID_chacha20_poly1305,
571     1,                  /* block_size */
572     CHACHA_KEY_SIZE,    /* key_len */
573     12,                 /* iv_len, 96-bit nonce in the context */
574     EVP_CIPH_FLAG_AEAD_CIPHER | EVP_CIPH_CUSTOM_IV |
575     EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT |
576     EVP_CIPH_CUSTOM_COPY | EVP_CIPH_FLAG_CUSTOM_CIPHER,
577     chacha20_poly1305_init_key,
578     chacha20_poly1305_cipher,
579     chacha20_poly1305_cleanup,
580     0,          /* 0 moves context-specific structure allocation to ctrl */
581     NULL,       /* set_asn1_parameters */
582     NULL,       /* get_asn1_parameters */
583     chacha20_poly1305_ctrl,
584     NULL        /* app_data */
585 };
586
587 const EVP_CIPHER *EVP_chacha20_poly1305(void)
588 {
589     return(&chacha20_poly1305);
590 }
591 # endif
592 #endif