e3a0bef8c5896c7cadab4548d04c63fec1855148
[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     0,                      /* flags */
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     struct { uint64_t aad, text; } len;
154     int aad, mac_inited, tag_len, nonce_len;
155     size_t tls_payload_length;
156 } EVP_CHACHA_AEAD_CTX;
157
158 #  define NO_TLS_PAYLOAD_LENGTH ((size_t)-1)
159 #  define aead_data(ctx)        ((EVP_CHACHA_AEAD_CTX *)(ctx)->cipher_data)
160 #  define POLY1305_ctx(actx)    ((POLY1305 *)(actx + 1))
161
162 static int chacha20_poly1305_init_key(EVP_CIPHER_CTX *ctx,
163                                       const unsigned char *inkey,
164                                       const unsigned char *iv, int enc)
165 {
166     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
167     unsigned char temp[CHACHA_CTR_SIZE];
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     /* pad on the left */
179     memset(temp, 0, sizeof(temp));
180     if (actx->nonce_len <= CHACHA_CTR_SIZE)
181         memcpy(temp + CHACHA_CTR_SIZE - actx->nonce_len, iv, actx->nonce_len);
182
183     chacha_init_key(ctx, inkey, temp, enc);
184
185     actx->nonce[0] = actx->key.counter[1];
186     actx->nonce[1] = actx->key.counter[2];
187     actx->nonce[2] = actx->key.counter[3];
188
189     return 1;
190 }
191
192 static int chacha20_poly1305_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
193                                     const unsigned char *in, size_t len)
194 {
195     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
196     size_t rem, plen = actx->tls_payload_length;
197     static const unsigned char zero[POLY1305_BLOCK_SIZE] = { 0 };
198
199     if (!actx->mac_inited) {
200         actx->key.counter[0] = 0;
201         memset(actx->key.buf, 0, sizeof(actx->key.buf));
202         ChaCha20_ctr32(actx->key.buf, actx->key.buf, CHACHA_BLK_SIZE,
203                        actx->key.key.d, actx->key.counter);
204         Poly1305_Init(POLY1305_ctx(actx), actx->key.buf);
205         actx->key.counter[0] = 1;
206         actx->key.partial_len = 0;
207         actx->len.aad = actx->len.text = 0;
208         actx->mac_inited = 1;
209     }
210
211     if (in) {                                   /* aad or text */
212         if (out == NULL) {                      /* aad */
213             Poly1305_Update(POLY1305_ctx(actx), in, len);
214             actx->len.aad += len;
215             actx->aad = 1;
216             return len;
217         } else {                                /* plain- or ciphertext */
218             if (actx->aad) {                    /* wrap up aad */
219                 if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
220                     Poly1305_Update(POLY1305_ctx(actx), zero,
221                                     POLY1305_BLOCK_SIZE - rem);
222                 actx->aad = 0;
223             }
224
225             actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
226             if (plen == NO_TLS_PAYLOAD_LENGTH)
227                 plen = len;
228             else if (len != plen + POLY1305_BLOCK_SIZE)
229                 return -1;
230
231             if (ctx->encrypt) {                 /* plaintext */
232                 chacha_cipher(ctx, out, in, plen);
233                 Poly1305_Update(POLY1305_ctx(actx), out, plen);
234                 in += plen;
235                 out += plen;
236                 actx->len.text += plen;
237             } else {                            /* ciphertext */
238                 Poly1305_Update(POLY1305_ctx(actx), in, plen);
239                 chacha_cipher(ctx, out, in, plen);
240                 in += plen;
241                 out += plen;
242                 actx->len.text += plen;
243             }
244         }
245     }
246     if (in == NULL                              /* explicit final */
247         || plen != len) {                       /* or tls mode */
248         const union {
249             long one;
250             char little;
251         } is_endian = { 1 };
252         unsigned char temp[POLY1305_BLOCK_SIZE];
253
254         if (actx->aad) {                        /* wrap up aad */
255             if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
256                 Poly1305_Update(POLY1305_ctx(actx), zero,
257                                 POLY1305_BLOCK_SIZE - rem);
258             actx->aad = 0;
259         }
260
261         if ((rem = (size_t)actx->len.text % POLY1305_BLOCK_SIZE))
262             Poly1305_Update(POLY1305_ctx(actx), zero,
263                             POLY1305_BLOCK_SIZE - rem);
264
265         if (is_endian.little) {
266             Poly1305_Update(POLY1305_ctx(actx),
267                             (unsigned char *)&actx->len, POLY1305_BLOCK_SIZE);
268         } else {
269             temp[0]  = (unsigned char)(actx->len.aad);
270             temp[1]  = (unsigned char)(actx->len.aad>>8);
271             temp[2]  = (unsigned char)(actx->len.aad>>16);
272             temp[3]  = (unsigned char)(actx->len.aad>>24);
273             temp[4]  = (unsigned char)(actx->len.aad>>32);
274             temp[5]  = (unsigned char)(actx->len.aad>>40);
275             temp[6]  = (unsigned char)(actx->len.aad>>48);
276             temp[7]  = (unsigned char)(actx->len.aad>>56);
277
278             temp[8]  = (unsigned char)(actx->len.text);
279             temp[9]  = (unsigned char)(actx->len.text>>8);
280             temp[10] = (unsigned char)(actx->len.text>>16);
281             temp[11] = (unsigned char)(actx->len.text>>24);
282             temp[12] = (unsigned char)(actx->len.text>>32);
283             temp[13] = (unsigned char)(actx->len.text>>40);
284             temp[14] = (unsigned char)(actx->len.text>>48);
285             temp[15] = (unsigned char)(actx->len.text>>56);
286
287             Poly1305_Update(POLY1305_ctx(actx), temp, POLY1305_BLOCK_SIZE);
288         }
289         Poly1305_Final(POLY1305_ctx(actx), ctx->encrypt ? actx->tag
290                                                         : temp);
291         actx->mac_inited = 0;
292
293         if (in != NULL && len != plen) {        /* tls mode */
294             if (ctx->encrypt) {
295                 memcpy(out, actx->tag, POLY1305_BLOCK_SIZE);
296             } else {
297                 if (CRYPTO_memcmp(temp, in, POLY1305_BLOCK_SIZE)) {
298                     memset(out, 0, plen);
299                     return -1;
300                 }
301             }
302         }
303         else if (!ctx->encrypt) {
304             if (CRYPTO_memcmp(temp, actx->tag, actx->tag_len))
305                 return -1;
306         }
307     }
308     return len;
309 }
310
311 static int chacha20_poly1305_cleanup(EVP_CIPHER_CTX *ctx)
312 {
313     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
314     if (actx)
315         OPENSSL_cleanse(ctx->cipher_data, sizeof(*ctx) + Poly1305_ctx_size());
316     return 1;
317 }
318
319 static int chacha20_poly1305_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg,
320                                   void *ptr)
321 {
322     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
323
324     switch(type) {
325     case EVP_CTRL_INIT:
326         if (actx == NULL)
327             actx = ctx->cipher_data
328                  = OPENSSL_zalloc(sizeof(*actx) + Poly1305_ctx_size());
329         if (actx == NULL) {
330             EVPerr(EVP_F_CHACHA20_POLY1305_CTRL, EVP_R_INITIALIZATION_ERROR);
331             return 0;
332         }
333         actx->len.aad = 0;
334         actx->len.text = 0;
335         actx->aad = 0;
336         actx->mac_inited = 0;
337         actx->tag_len = 0;
338         actx->nonce_len = 12;
339         actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
340         return 1;
341
342     case EVP_CTRL_COPY:
343         if (actx) {
344             if ((((EVP_CIPHER_CTX *)ptr)->cipher_data =
345                    OPENSSL_memdup(actx,sizeof(*actx) + Poly1305_ctx_size()))
346                 == NULL) {
347                 EVPerr(EVP_F_CHACHA20_POLY1305_CTRL, EVP_R_COPY_ERROR);
348                 return 0;
349             }
350         }
351         return 1;
352
353     case EVP_CTRL_AEAD_SET_IVLEN:
354         if (arg <= 0 || arg > CHACHA_CTR_SIZE)
355             return 0;
356         actx->nonce_len = arg;
357         return 1;
358
359     case EVP_CTRL_AEAD_SET_IV_FIXED:
360         if (arg != 12)
361             return 0;
362         actx->nonce[0] = actx->key.counter[1]
363                        = CHACHA_U8TOU32((unsigned char *)ptr);
364         actx->nonce[1] = actx->key.counter[2]
365                        = CHACHA_U8TOU32((unsigned char *)ptr+4);
366         actx->nonce[2] = actx->key.counter[3]
367                        = CHACHA_U8TOU32((unsigned char *)ptr+8);
368         return 1;
369
370     case EVP_CTRL_AEAD_SET_TAG:
371         if (arg <= 0 || arg > POLY1305_BLOCK_SIZE)
372             return 0;
373         if (ptr != NULL) {
374             memcpy(actx->tag, ptr, arg);
375             actx->tag_len = arg;
376         }
377         return 1;
378
379     case EVP_CTRL_AEAD_GET_TAG:
380         if (arg <= 0 || arg > POLY1305_BLOCK_SIZE || !ctx->encrypt)
381             return 0;
382         memcpy(ptr, actx->tag, arg);
383         return 1;
384
385     case EVP_CTRL_AEAD_TLS1_AAD:
386         if (arg != EVP_AEAD_TLS1_AAD_LEN)
387             return 0;
388         {
389             unsigned int len;
390             unsigned char *aad = ptr, temp[POLY1305_BLOCK_SIZE];
391
392             len = aad[EVP_AEAD_TLS1_AAD_LEN - 2] << 8 |
393                   aad[EVP_AEAD_TLS1_AAD_LEN - 1];
394             if (!ctx->encrypt) {
395                 len -= POLY1305_BLOCK_SIZE;     /* discount attached tag */
396                 memcpy(temp, aad, EVP_AEAD_TLS1_AAD_LEN - 2);
397                 aad = temp;
398                 temp[EVP_AEAD_TLS1_AAD_LEN - 2] = (unsigned char)(len >> 8);
399                 temp[EVP_AEAD_TLS1_AAD_LEN - 1] = (unsigned char)len;
400             }
401             actx->tls_payload_length = len;
402
403             /*
404              * merge record sequence number as per
405              * draft-ietf-tls-chacha20-poly1305-03
406              */
407             actx->key.counter[1] = actx->nonce[0];
408             actx->key.counter[2] = actx->nonce[1] ^ CHACHA_U8TOU32(aad);
409             actx->key.counter[3] = actx->nonce[2] ^ CHACHA_U8TOU32(aad+4);
410             actx->mac_inited = 0;
411             chacha20_poly1305_cipher(ctx, NULL, aad, EVP_AEAD_TLS1_AAD_LEN);
412             return POLY1305_BLOCK_SIZE;         /* tag length */
413         }
414
415     case EVP_CTRL_AEAD_SET_MAC_KEY:
416         /* no-op */
417         return 1;
418
419     default:
420         return -1;
421     }
422 }
423
424 static EVP_CIPHER chacha20_poly1305 = {
425     NID_chacha20_poly1305,
426     1,                  /* block_size */
427     CHACHA_KEY_SIZE,    /* key_len */
428     12,                 /* iv_len, 96-bit nonce in the context */
429     EVP_CIPH_FLAG_AEAD_CIPHER | EVP_CIPH_CUSTOM_IV |
430     EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT |
431     EVP_CIPH_CUSTOM_COPY | EVP_CIPH_FLAG_CUSTOM_CIPHER,
432     chacha20_poly1305_init_key,
433     chacha20_poly1305_cipher,
434     chacha20_poly1305_cleanup,
435     0,          /* 0 moves context-specific structure allocation to ctrl */
436     NULL,       /* set_asn1_parameters */
437     NULL,       /* get_asn1_parameters */
438     chacha20_poly1305_ctrl,
439     NULL        /* app_data */
440 };
441
442 const EVP_CIPHER *EVP_chacha20_poly1305(void)
443 {
444     return(&chacha20_poly1305);
445 }
446 # endif
447 #endif