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