crypto/evp: add e_chacha20_poly1305.c.
[openssl.git] / crypto / evp / e_chacha20_poly1305.c
1 /* ====================================================================
2  * Copyright (c) 2014 The OpenSSL Project.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  *
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in
13  *    the documentation and/or other materials provided with the
14  *    distribution.
15  *
16  * 3. All advertising materials mentioning features or use of this
17  *    software must display the following acknowledgment:
18  *    "This product includes software developed by the OpenSSL Project
19  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
20  *
21  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
22  *    endorse or promote products derived from this software without
23  *    prior written permission. For written permission, please contact
24  *    openssl-core@openssl.org.
25  *
26  * 5. Products derived from this software may not be called "OpenSSL"
27  *    nor may "OpenSSL" appear in their names without prior written
28  *    permission of the OpenSSL Project.
29  *
30  * 6. Redistributions of any form whatsoever must retain the following
31  *    acknowledgment:
32  *    "This product includes software developed by the OpenSSL Project
33  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
34  *
35  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
36  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
46  * OF THE POSSIBILITY OF SUCH DAMAGE.
47  * ====================================================================
48  *
49  */
50
51 #include <stdio.h>
52 #include "internal/cryptlib.h"
53
54 #ifndef OPENSSL_NO_CHACHA
55
56 # include <openssl/evp.h>
57 # include <openssl/objects.h>
58 # include "evp_locl.h"
59 # include "internal/evp_int.h"
60 # include "internal/chacha.h"
61
62 typedef struct {
63     union {
64         double align;   /* this ensures even sizeof(EVP_CHACHA_KEY)%8==0 */
65         unsigned int d[CHACHA_KEY_SIZE / 4];
66     } key;
67     unsigned int  counter[CHACHA_CTR_SIZE / 4];
68     unsigned char buf[CHACHA_BLK_SIZE];
69     unsigned int  partial_len;
70 } EVP_CHACHA_KEY;
71
72 #define data(ctx)   ((EVP_CHACHA_KEY *)(ctx)->cipher_data)
73
74 static int chacha_init_key(EVP_CIPHER_CTX *ctx,
75                            const unsigned char user_key[CHACHA_KEY_SIZE],
76                            const unsigned char iv[CHACHA_CTR_SIZE], int enc)
77 {
78     EVP_CHACHA_KEY *key = data(ctx);
79     unsigned int i;
80
81     if (user_key)
82         for (i = 0; i < CHACHA_KEY_SIZE; i+=4) {
83             key->key.d[i/4] = CHACHA_U8TOU32(user_key+i);
84         }
85
86     if (iv)
87         for (i = 0; i < CHACHA_CTR_SIZE; i+=4) {
88             key->counter[i/4] = CHACHA_U8TOU32(iv+i);
89         }
90
91     key->partial_len = 0;
92
93     return 1;
94 }
95
96 static int chacha_cipher(EVP_CIPHER_CTX * ctx, unsigned char *out,
97                          const unsigned char *inp, size_t len)
98 {
99     EVP_CHACHA_KEY *key = data(ctx);
100     unsigned int n, rem, ctr32;
101
102     if ((n = key->partial_len)) {
103         while (len && n < CHACHA_BLK_SIZE) {
104             *out++ = *inp++ ^ key->buf[n++];
105             len--;
106         }
107         key->partial_len = n;
108
109         if (len == 0)
110             return 1;
111
112         if (n == CHACHA_BLK_SIZE) {
113             key->partial_len = 0;
114             key->counter[0]++;
115             if (key->counter[0] == 0)
116                 key->counter[1]++;
117         }
118     }
119
120     rem = (unsigned int)(len % CHACHA_BLK_SIZE);
121     len -= rem;
122     ctr32 = key->counter[0];
123     while (len >= CHACHA_BLK_SIZE) {
124         size_t blocks = len / CHACHA_BLK_SIZE;
125         /*
126          * 1<<28 is just a not-so-small yet not-so-large number...
127          * Below condition is practically never met, but it has to
128          * be checked for code correctness.
129          */
130         if (sizeof(size_t)>sizeof(unsigned int) && blocks>(1U<<28))
131             blocks = (1U<<28);
132
133         /*
134          * As ChaCha20_ctr32 operates on 32-bit counter, caller
135          * has to handle overflow. 'if' below detects the
136          * overflow, which is then handled by limiting the
137          * amount of blocks to the exact overflow point...
138          */
139         ctr32 += (unsigned int)blocks;
140         if (ctr32 < blocks) {
141             blocks -= ctr32;
142             ctr32 = 0;
143         }
144         blocks *= CHACHA_BLK_SIZE;
145         ChaCha20_ctr32(out, inp, blocks, key->key.d, key->counter);
146         len -= blocks;
147         inp += blocks;
148         out += blocks;
149
150         key->counter[0] = ctr32;
151         if (ctr32 == 0) key->counter[1]++;
152     }
153
154     if (rem) {
155         memset(key->buf, 0, sizeof(key->buf));
156         ChaCha20_ctr32(key->buf, key->buf, CHACHA_BLK_SIZE,
157                        key->key.d, key->counter);
158         for (n = 0; n < rem; n++)
159             out[n] = inp[n] ^ key->buf[n];
160         key->partial_len = rem;
161     }
162
163     return 1;
164 }
165
166 static const EVP_CIPHER chacha20 = {
167     NID_chacha20,
168     1,                      /* block_size */
169     CHACHA_KEY_SIZE,        /* key_len */
170     CHACHA_CTR_SIZE,        /* iv_len, 128-bit counter in the context */
171     0,                      /* flags */
172     chacha_init_key,
173     chacha_cipher,
174     NULL,
175     sizeof(EVP_CHACHA_KEY),
176     NULL,
177     NULL,
178     NULL,
179     NULL
180 };
181
182 const EVP_CIPHER *EVP_chacha20(void)
183 {
184     return (&chacha20);
185 }
186
187 # ifndef OPENSSL_NO_POLY1305
188 #  include "internal/poly1305.h"
189
190 typedef struct {
191     EVP_CHACHA_KEY key;
192     unsigned int nonce[12/4];
193     unsigned char tag[POLY1305_BLOCK_SIZE];
194     struct { uint64_t aad, text; } len;
195     int aad, mac_inited, tag_len, nonce_len;
196     size_t tls_payload_length;
197 } EVP_CHACHA_AEAD_CTX;
198
199 #  define NO_TLS_PAYLOAD_LENGTH ((size_t)-1)
200 #  define aead_data(ctx)        ((EVP_CHACHA_AEAD_CTX *)(ctx)->cipher_data)
201 #  define POLY1305_ctx(actx)    ((POLY1305 *)(actx + 1))
202
203 static int chacha20_poly1305_init_key(EVP_CIPHER_CTX *ctx,
204                                       const unsigned char *inkey,
205                                       const unsigned char *iv, int enc)
206 {
207     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
208     unsigned char temp[CHACHA_CTR_SIZE];
209
210     if (!inkey && !iv)
211         return 1;
212
213     actx->len.aad = 0;
214     actx->len.text = 0;
215     actx->aad = 0;
216     actx->mac_inited = 0;
217     actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
218
219     /* pad on the left */
220     memset(temp, 0, sizeof(temp));
221     if (actx->nonce_len <= CHACHA_CTR_SIZE)
222         memcpy(temp + CHACHA_CTR_SIZE - actx->nonce_len, iv, actx->nonce_len);
223
224     chacha_init_key(ctx, inkey, temp, enc);
225
226     actx->nonce[0] = actx->key.counter[1];
227     actx->nonce[1] = actx->key.counter[2];
228     actx->nonce[2] = actx->key.counter[3];
229
230     return 1;
231 }
232
233 static int chacha20_poly1305_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
234                                     const unsigned char *in, size_t len)
235 {
236     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
237     size_t rem, plen = actx->tls_payload_length;
238     static const unsigned char zero[POLY1305_BLOCK_SIZE] = { 0 };
239
240     if (!actx->mac_inited) {
241         actx->key.counter[0] = 0;
242         memset(actx->key.buf, 0, sizeof(actx->key.buf));
243         ChaCha20_ctr32(actx->key.buf, actx->key.buf, CHACHA_BLK_SIZE,
244                        actx->key.key.d, actx->key.counter);
245         Poly1305_Init(POLY1305_ctx(actx), actx->key.buf);
246         actx->key.counter[0] = 1;
247         actx->mac_inited = 1;
248     }
249
250     if (in) {                                   /* aad or text */
251         if (out == NULL) {                      /* aad */
252             Poly1305_Update(POLY1305_ctx(actx), in, len);
253             actx->len.aad += len;
254             actx->aad = 1;
255             return len;
256         } else {                                /* plain- or ciphertext */
257             if (actx->aad) {                    /* wrap up aad */
258                 if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
259                     Poly1305_Update(POLY1305_ctx(actx), zero,
260                                     POLY1305_BLOCK_SIZE - rem);
261                 actx->aad = 0;
262             }
263
264             actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
265             if (plen == NO_TLS_PAYLOAD_LENGTH)
266                 plen = len;
267             else if (len != plen + POLY1305_BLOCK_SIZE)
268                 return -1;
269
270             if (ctx->encrypt) {                 /* plaintext */
271                 chacha_cipher(ctx, out, in, plen);
272                 Poly1305_Update(POLY1305_ctx(actx), out, plen);
273                 in += plen;
274                 out += plen;
275                 actx->len.text += plen;
276             } else {                            /* ciphertext */
277                 Poly1305_Update(POLY1305_ctx(actx), in, plen);
278                 chacha_cipher(ctx, out, in, plen);
279                 in += plen;
280                 out += plen;
281                 actx->len.text += plen;
282             }
283         }
284     }
285     if (in == NULL                              /* explicit final */
286         || plen != len) {                       /* or tls mode */
287         const union {
288             long one;
289             char little;
290         } is_endian = { 1 };
291         unsigned char temp[POLY1305_BLOCK_SIZE];
292
293         if (actx->aad) {                        /* wrap up aad */
294             if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
295                 Poly1305_Update(POLY1305_ctx(actx), zero,
296                                 POLY1305_BLOCK_SIZE - rem);
297             actx->aad = 0;
298         }
299
300         if ((rem = (size_t)actx->len.text % POLY1305_BLOCK_SIZE))
301             Poly1305_Update(POLY1305_ctx(actx), zero,
302                             POLY1305_BLOCK_SIZE - rem);
303
304         if (is_endian.little) {
305             Poly1305_Update(POLY1305_ctx(actx),
306                             (unsigned char *)&actx->len, POLY1305_BLOCK_SIZE);
307         } else {
308             temp[0]  = (unsigned char)(actx->len.aad);
309             temp[1]  = (unsigned char)(actx->len.aad>>8);
310             temp[2]  = (unsigned char)(actx->len.aad>>16);
311             temp[3]  = (unsigned char)(actx->len.aad>>24);
312             temp[4]  = (unsigned char)(actx->len.aad>>32);
313             temp[5]  = (unsigned char)(actx->len.aad>>40);
314             temp[6]  = (unsigned char)(actx->len.aad>>48);
315             temp[7]  = (unsigned char)(actx->len.aad>>56);
316
317             temp[8]  = (unsigned char)(actx->len.text);
318             temp[9]  = (unsigned char)(actx->len.text>>8);
319             temp[10] = (unsigned char)(actx->len.text>>16);
320             temp[11] = (unsigned char)(actx->len.text>>24);
321             temp[12] = (unsigned char)(actx->len.text>>32);
322             temp[13] = (unsigned char)(actx->len.text>>40);
323             temp[14] = (unsigned char)(actx->len.text>>48);
324             temp[15] = (unsigned char)(actx->len.text>>56);
325
326             Poly1305_Update(POLY1305_ctx(actx), temp, POLY1305_BLOCK_SIZE);
327         }
328         Poly1305_Final(POLY1305_ctx(actx), ctx->encrypt ? actx->tag
329                                                         : temp);
330         actx->mac_inited = 0;
331
332         if (in != NULL && len != plen) {        /* tls mode */
333             if (ctx->encrypt) {
334                 memcpy(out, actx->tag, POLY1305_BLOCK_SIZE);
335             } else {
336                 if (CRYPTO_memcmp(temp, in, POLY1305_BLOCK_SIZE)) {
337                     memset(out, 0, plen);
338                     return -1;
339                 }
340             }
341         }
342         else if (!ctx->encrypt) {
343             if (CRYPTO_memcmp(temp, actx->tag, actx->tag_len))
344                 return -1;
345         }
346     }
347     return len;
348 }
349
350 static int chacha20_poly1305_cleanup(EVP_CIPHER_CTX *ctx)
351 {
352     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
353     if (actx)
354         OPENSSL_cleanse(ctx->cipher_data, sizeof(*ctx) + Poly1305_ctx_size());
355     return 1;
356 }
357
358 static int chacha20_poly1305_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg,
359                                   void *ptr)
360 {
361     EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
362
363     switch(type) {
364     case EVP_CTRL_INIT:
365         if (actx == NULL)
366             actx = ctx->cipher_data
367                  = OPENSSL_zalloc(sizeof(*actx) + Poly1305_ctx_size());
368         if (actx == NULL) {
369             EVPerr(EVP_F_CHACHA20_POLY1305_CTRL, EVP_R_INITIALIZATION_ERROR);
370             return 0;
371         }
372         actx->len.aad = 0;
373         actx->len.text = 0;
374         actx->aad = 0;
375         actx->mac_inited = 0;
376         actx->tag_len = 0;
377         actx->nonce_len = 12;
378         actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
379         return 1;
380
381     case EVP_CTRL_COPY:
382         if (actx) {
383             if ((((EVP_CIPHER_CTX *)ptr)->cipher_data =
384                    BUF_memdup(actx,sizeof(*actx) + Poly1305_ctx_size()))
385                 == NULL) {
386                 EVPerr(EVP_F_CHACHA20_POLY1305_CTRL, EVP_R_COPY_ERROR);
387                 return 0;
388             }
389         }
390         return 1;
391
392     case EVP_CTRL_AEAD_SET_IVLEN:
393         if (arg <= 0 || arg > CHACHA_CTR_SIZE)
394             return 0;
395         actx->nonce_len = arg;
396         return 1;
397
398     case EVP_CTRL_AEAD_SET_IV_FIXED:
399         if (arg != 12)
400             return 0;
401         actx->nonce[0] = actx->key.counter[1]
402                        = CHACHA_U8TOU32((unsigned char *)ptr);
403         actx->nonce[1] = actx->key.counter[2]
404                        = CHACHA_U8TOU32((unsigned char *)ptr+4);
405         actx->nonce[2] = actx->key.counter[3]
406                        = CHACHA_U8TOU32((unsigned char *)ptr+8);
407         return 1;
408
409     case EVP_CTRL_AEAD_SET_TAG:
410         if (arg <= 0 || arg > POLY1305_BLOCK_SIZE)
411             return 0;
412         if (ptr != NULL) {
413             memcpy(actx->tag, ptr, arg);
414             actx->tag_len = arg;
415         }
416         return 1;
417
418     case EVP_CTRL_AEAD_GET_TAG:
419         if (arg <= 0 || arg > POLY1305_BLOCK_SIZE || !ctx->encrypt)
420             return 0;
421         memcpy(ptr, actx->tag, arg);
422         return 1;
423
424     case EVP_CTRL_AEAD_TLS1_AAD:
425         if (arg != EVP_AEAD_TLS1_AAD_LEN)
426             return 0;
427         {
428             unsigned int len;
429             unsigned char temp[POLY1305_BLOCK_SIZE];
430
431             /*
432              * compose padded aad
433              */
434             memset(temp, 0, sizeof(temp));
435             memcpy(temp, ptr, EVP_AEAD_TLS1_AAD_LEN);
436
437             len = temp[EVP_AEAD_TLS1_AAD_LEN - 2] << 8 |
438                   temp[EVP_AEAD_TLS1_AAD_LEN - 1];
439             if (!ctx->encrypt) {
440                 len -= POLY1305_BLOCK_SIZE;     /* discount attached tag */
441                 temp[EVP_AEAD_TLS1_AAD_LEN - 2] = (unsigned char)(len >> 8);
442                 temp[EVP_AEAD_TLS1_AAD_LEN - 1] = (unsigned char)len;
443             }
444             actx->tls_payload_length = len;
445
446             /*
447              * merge record sequence number as per
448              * draft-ietf-tls-chacha20-poly1305-03
449              */
450             actx->key.counter[1] = actx->nonce[0];
451             actx->key.counter[2] = actx->nonce[1] ^ CHACHA_U8TOU32(temp);
452             actx->key.counter[3] = actx->nonce[2] ^ CHACHA_U8TOU32(temp+4);
453             actx->mac_inited = 0;
454             chacha20_poly1305_cipher(ctx, NULL, temp, POLY1305_BLOCK_SIZE);
455             return POLY1305_BLOCK_SIZE;         /* tag length */
456         }
457
458     case EVP_CTRL_AEAD_SET_MAC_KEY:
459         /* no-op */
460         return 1;
461
462     default:
463         return -1;
464     }
465 }
466
467 static EVP_CIPHER chacha20_poly1305 = {
468     NID_chacha20_poly1305,
469     1,                  /* block_size */
470     CHACHA_KEY_SIZE,    /* key_len */
471     12,                 /* iv_len, 96-bit nonce in the context */
472     EVP_CIPH_FLAG_AEAD_CIPHER | EVP_CIPH_CUSTOM_IV |
473     EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT |
474     EVP_CIPH_CUSTOM_COPY | EVP_CIPH_FLAG_CUSTOM_CIPHER,
475     chacha20_poly1305_init_key,
476     chacha20_poly1305_cipher,
477     chacha20_poly1305_cleanup,
478     0,          /* 0 moves context-specific structure allocation to ctrl */
479     NULL,       /* set_asn1_parameters */
480     NULL,       /* get_asn1_parameters */
481     chacha20_poly1305_ctrl,
482     NULL        /* app_data */
483 };
484
485 const EVP_CIPHER *EVP_chacha20_poly1305(void)
486 {
487     return(&chacha20_poly1305);
488 }
489 # endif
490 #endif