crypto/rand/drbg_ctr.c

   1 /*
   2  * Copyright 2011-2018 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (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 <stdlib.h>
  11 #include <string.h>
  12 #include <openssl/crypto.h>
  13 #include <openssl/err.h>
  14 #include <openssl/rand.h>
  15 #include "internal/thread_once.h"
  16 #include "rand_lcl.h"
  17
  18 /*
  19  * Implementation of NIST SP 800-90A CTR DRBG.
  20  */
  21 static void inc_128(RAND_DRBG_CTR *ctr)
  22 {
  23     int i;
  24     unsigned char c;
  25     unsigned char *p = &ctr->V[15];
  26
  27     for (i = 0; i < 16; i++, p--) {
  28         c = *p;
  29         c++;
  30         *p = c;
  31         if (c != 0) {
  32             /* If we didn't wrap around, we're done. */
  33             break;
  34         }
  35     }
  36 }
  37
  38 static void ctr_XOR(RAND_DRBG_CTR *ctr, const unsigned char *in, size_t inlen)
  39 {
  40     size_t i, n;
  41
  42     if (in == NULL || inlen == 0)
  43         return;
  44
  45     /*
  46      * Any zero padding will have no effect on the result as we
  47      * are XORing. So just process however much input we have.
  48      */
  49     n = inlen < ctr->keylen ? inlen : ctr->keylen;
  50     for (i = 0; i < n; i++)
  51         ctr->K[i] ^= in[i];
  52     if (inlen <= ctr->keylen)
  53         return;
  54
  55     n = inlen - ctr->keylen;
  56     if (n > 16) {
  57         /* Should never happen */
  58         n = 16;
  59     }
  60     for (i = 0; i < n; i++)
  61         ctr->V[i] ^= in[i + ctr->keylen];
  62 }
  63
  64 /*
  65  * Process a complete block using BCC algorithm of SP 800-90A 10.3.3
  66  */
  67 __owur static int ctr_BCC_block(RAND_DRBG_CTR *ctr, unsigned char *out,
  68                                 const unsigned char *in)
  69 {
  70     int i, outlen = AES_BLOCK_SIZE;
  71
  72     for (i = 0; i < 16; i++)
  73         out[i] ^= in[i];
  74
  75     if (!EVP_CipherUpdate(ctr->ctx_df, out, &outlen, out, AES_BLOCK_SIZE)
  76         || outlen != AES_BLOCK_SIZE)
  77         return 0;
  78     return 1;
  79 }
  80
  81
  82 /*
  83  * Handle several BCC operations for as much data as we need for K and X
  84  */
  85 __owur static int ctr_BCC_blocks(RAND_DRBG_CTR *ctr, const unsigned char *in)
  86 {
  87     if (!ctr_BCC_block(ctr, ctr->KX, in)
  88         || !ctr_BCC_block(ctr, ctr->KX + 16, in))
  89         return 0;
  90     if (ctr->keylen != 16 && !ctr_BCC_block(ctr, ctr->KX + 32, in))
  91         return 0;
  92     return 1;
  93 }
  94
  95 /*
  96  * Initialise BCC blocks: these have the value 0,1,2 in leftmost positions:
  97  * see 10.3.1 stage 7.
  98  */
  99 __owur static int ctr_BCC_init(RAND_DRBG_CTR *ctr)
 100 {
 101     memset(ctr->KX, 0, 48);
 102     memset(ctr->bltmp, 0, 16);
 103     if (!ctr_BCC_block(ctr, ctr->KX, ctr->bltmp))
 104         return 0;
 105     ctr->bltmp[3] = 1;
 106     if (!ctr_BCC_block(ctr, ctr->KX + 16, ctr->bltmp))
 107         return 0;
 108     if (ctr->keylen != 16) {
 109         ctr->bltmp[3] = 2;
 110         if (!ctr_BCC_block(ctr, ctr->KX + 32, ctr->bltmp))
 111             return 0;
 112     }
 113     return 1;
 114 }
 115
 116 /*
 117  * Process several blocks into BCC algorithm, some possibly partial
 118  */
 119 __owur static int ctr_BCC_update(RAND_DRBG_CTR *ctr,
 120                                  const unsigned char *in, size_t inlen)
 121 {
 122     if (in == NULL || inlen == 0)
 123         return 1;
 124
 125     /* If we have partial block handle it first */
 126     if (ctr->bltmp_pos) {
 127         size_t left = 16 - ctr->bltmp_pos;
 128
 129         /* If we now have a complete block process it */
 130         if (inlen >= left) {
 131             memcpy(ctr->bltmp + ctr->bltmp_pos, in, left);
 132             if (!ctr_BCC_blocks(ctr, ctr->bltmp))
 133                 return 0;
 134             ctr->bltmp_pos = 0;
 135             inlen -= left;
 136             in += left;
 137         }
 138     }
 139
 140     /* Process zero or more complete blocks */
 141     for (; inlen >= 16; in += 16, inlen -= 16) {
 142         if (!ctr_BCC_blocks(ctr, in))
 143             return 0;
 144     }
 145
 146     /* Copy any remaining partial block to the temporary buffer */
 147     if (inlen > 0) {
 148         memcpy(ctr->bltmp + ctr->bltmp_pos, in, inlen);
 149         ctr->bltmp_pos += inlen;
 150     }
 151     return 1;
 152 }
 153
 154 __owur static int ctr_BCC_final(RAND_DRBG_CTR *ctr)
 155 {
 156     if (ctr->bltmp_pos) {
 157         memset(ctr->bltmp + ctr->bltmp_pos, 0, 16 - ctr->bltmp_pos);
 158         if (!ctr_BCC_blocks(ctr, ctr->bltmp))
 159             return 0;
 160     }
 161     return 1;
 162 }
 163
 164 __owur static int ctr_df(RAND_DRBG_CTR *ctr,
 165                          const unsigned char *in1, size_t in1len,
 166                          const unsigned char *in2, size_t in2len,
 167                          const unsigned char *in3, size_t in3len)
 168 {
 169     static unsigned char c80 = 0x80;
 170     size_t inlen;
 171     unsigned char *p = ctr->bltmp;
 172     int outlen = AES_BLOCK_SIZE;
 173
 174     if (!ctr_BCC_init(ctr))
 175         return 0;
 176     if (in1 == NULL)
 177         in1len = 0;
 178     if (in2 == NULL)
 179         in2len = 0;
 180     if (in3 == NULL)
 181         in3len = 0;
 182     inlen = in1len + in2len + in3len;
 183     /* Initialise L||N in temporary block */
 184     *p++ = (inlen >> 24) & 0xff;
 185     *p++ = (inlen >> 16) & 0xff;
 186     *p++ = (inlen >> 8) & 0xff;
 187     *p++ = inlen & 0xff;
 188
 189     /* NB keylen is at most 32 bytes */
 190     *p++ = 0;
 191     *p++ = 0;
 192     *p++ = 0;
 193     *p = (unsigned char)((ctr->keylen + 16) & 0xff);
 194     ctr->bltmp_pos = 8;
 195     if (!ctr_BCC_update(ctr, in1, in1len)
 196         || !ctr_BCC_update(ctr, in2, in2len)
 197         || !ctr_BCC_update(ctr, in3, in3len)
 198         || !ctr_BCC_update(ctr, &c80, 1)
 199         || !ctr_BCC_final(ctr))
 200         return 0;
 201     /* Set up key K */
 202     if (!EVP_CipherInit_ex(ctr->ctx, ctr->cipher, NULL, ctr->KX, NULL, 1))
 203         return 0;
 204     /* X follows key K */
 205     if (!EVP_CipherUpdate(ctr->ctx, ctr->KX, &outlen, ctr->KX + ctr->keylen,
 206                           AES_BLOCK_SIZE)
 207         || outlen != AES_BLOCK_SIZE)
 208         return 0;
 209     if (!EVP_CipherUpdate(ctr->ctx, ctr->KX + 16, &outlen, ctr->KX,
 210                           AES_BLOCK_SIZE)
 211         || outlen != AES_BLOCK_SIZE)
 212         return 0;
 213     if (ctr->keylen != 16)
 214         if (!EVP_CipherUpdate(ctr->ctx, ctr->KX + 32, &outlen, ctr->KX + 16,
 215                               AES_BLOCK_SIZE)
 216             || outlen != AES_BLOCK_SIZE)
 217             return 0;
 218     return 1;
 219 }
 220
 221 /*
 222  * NB the no-df Update in SP800-90A specifies a constant input length
 223  * of seedlen, however other uses of this algorithm pad the input with
 224  * zeroes if necessary and have up to two parameters XORed together,
 225  * so we handle both cases in this function instead.
 226  */
 227 __owur static int ctr_update(RAND_DRBG *drbg,
 228                              const unsigned char *in1, size_t in1len,
 229                              const unsigned char *in2, size_t in2len,
 230                              const unsigned char *nonce, size_t noncelen)
 231 {
 232     RAND_DRBG_CTR *ctr = &drbg->data.ctr;
 233     int outlen = AES_BLOCK_SIZE;
 234
 235     /* correct key is already set up. */
 236     inc_128(ctr);
 237     if (!EVP_CipherUpdate(ctr->ctx, ctr->K, &outlen, ctr->V, AES_BLOCK_SIZE)
 238         || outlen != AES_BLOCK_SIZE)
 239         return 0;
 240
 241     /* If keylen longer than 128 bits need extra encrypt */
 242     if (ctr->keylen != 16) {
 243         inc_128(ctr);
 244         if (!EVP_CipherUpdate(ctr->ctx, ctr->K+16, &outlen, ctr->V,
 245                               AES_BLOCK_SIZE)
 246             || outlen != AES_BLOCK_SIZE)
 247             return 0;
 248     }
 249     inc_128(ctr);
 250     if (!EVP_CipherUpdate(ctr->ctx, ctr->V, &outlen, ctr->V, AES_BLOCK_SIZE)
 251         || outlen != AES_BLOCK_SIZE)
 252         return 0;
 253
 254     /* If 192 bit key part of V is on end of K */
 255     if (ctr->keylen == 24) {
 256         memcpy(ctr->V + 8, ctr->V, 8);
 257         memcpy(ctr->V, ctr->K + 24, 8);
 258     }
 259
 260     if ((drbg->flags & RAND_DRBG_FLAG_CTR_NO_DF) == 0) {
 261         /* If no input reuse existing derived value */
 262         if (in1 != NULL || nonce != NULL || in2 != NULL)
 263             if (!ctr_df(ctr, in1, in1len, nonce, noncelen, in2, in2len))
 264                 return 0;
 265         /* If this a reuse input in1len != 0 */
 266         if (in1len)
 267             ctr_XOR(ctr, ctr->KX, drbg->seedlen);
 268     } else {
 269         ctr_XOR(ctr, in1, in1len);
 270         ctr_XOR(ctr, in2, in2len);
 271     }
 272
 273     if (!EVP_CipherInit_ex(ctr->ctx, ctr->cipher, NULL, ctr->K, NULL, 1))
 274         return 0;
 275     return 1;
 276 }
 277
 278 __owur static int drbg_ctr_instantiate(RAND_DRBG *drbg,
 279                                        const unsigned char *entropy, size_t entropylen,
 280                                        const unsigned char *nonce, size_t noncelen,
 281                                        const unsigned char *pers, size_t perslen)
 282 {
 283     RAND_DRBG_CTR *ctr = &drbg->data.ctr;
 284
 285     if (entropy == NULL)
 286         return 0;
 287
 288     memset(ctr->K, 0, sizeof(ctr->K));
 289     memset(ctr->V, 0, sizeof(ctr->V));
 290     if (!EVP_CipherInit_ex(ctr->ctx, ctr->cipher, NULL, ctr->K, NULL, 1))
 291         return 0;
 292     if (!ctr_update(drbg, entropy, entropylen, pers, perslen, nonce, noncelen))
 293         return 0;
 294     return 1;
 295 }
 296
 297 __owur static int drbg_ctr_reseed(RAND_DRBG *drbg,
 298                                   const unsigned char *entropy, size_t entropylen,
 299                                   const unsigned char *adin, size_t adinlen)
 300 {
 301     if (entropy == NULL)
 302         return 0;
 303     if (!ctr_update(drbg, entropy, entropylen, adin, adinlen, NULL, 0))
 304         return 0;
 305     return 1;
 306 }
 307
 308 __owur static int drbg_ctr_generate(RAND_DRBG *drbg,
 309                                     unsigned char *out, size_t outlen,
 310                                     const unsigned char *adin, size_t adinlen)
 311 {
 312     RAND_DRBG_CTR *ctr = &drbg->data.ctr;
 313
 314     if (adin != NULL && adinlen != 0) {
 315         if (!ctr_update(drbg, adin, adinlen, NULL, 0, NULL, 0))
 316             return 0;
 317         /* This means we reuse derived value */
 318         if ((drbg->flags & RAND_DRBG_FLAG_CTR_NO_DF) == 0) {
 319             adin = NULL;
 320             adinlen = 1;
 321         }
 322     } else {
 323         adinlen = 0;
 324     }
 325
 326     for ( ; ; ) {
 327         int outl = AES_BLOCK_SIZE;
 328
 329         inc_128(ctr);
 330         if (outlen < 16) {
 331             /* Use K as temp space as it will be updated */
 332             if (!EVP_CipherUpdate(ctr->ctx, ctr->K, &outl, ctr->V,
 333                                   AES_BLOCK_SIZE)
 334                 || outl != AES_BLOCK_SIZE)
 335                 return 0;
 336             memcpy(out, ctr->K, outlen);
 337             break;
 338         }
 339         if (!EVP_CipherUpdate(ctr->ctx, out, &outl, ctr->V, AES_BLOCK_SIZE)
 340             || outl != AES_BLOCK_SIZE)
 341             return 0;
 342         out += 16;
 343         outlen -= 16;
 344         if (outlen == 0)
 345             break;
 346     }
 347
 348     if (!ctr_update(drbg, adin, adinlen, NULL, 0, NULL, 0))
 349         return 0;
 350     return 1;
 351 }
 352
 353 static int drbg_ctr_uninstantiate(RAND_DRBG *drbg)
 354 {
 355     EVP_CIPHER_CTX_free(drbg->data.ctr.ctx);
 356     EVP_CIPHER_CTX_free(drbg->data.ctr.ctx_df);
 357     OPENSSL_cleanse(&drbg->data.ctr, sizeof(drbg->data.ctr));
 358     return 1;
 359 }
 360
 361 static RAND_DRBG_METHOD drbg_ctr_meth = {
 362     drbg_ctr_instantiate,
 363     drbg_ctr_reseed,
 364     drbg_ctr_generate,
 365     drbg_ctr_uninstantiate
 366 };
 367
 368 int drbg_ctr_init(RAND_DRBG *drbg)
 369 {
 370     RAND_DRBG_CTR *ctr = &drbg->data.ctr;
 371     size_t keylen;
 372
 373     switch (drbg->type) {
 374     default:
 375         /* This can't happen, but silence the compiler warning. */
 376         return 0;
 377     case NID_aes_128_ctr:
 378         keylen = 16;
 379         ctr->cipher = EVP_aes_128_ecb();
 380         break;
 381     case NID_aes_192_ctr:
 382         keylen = 24;
 383         ctr->cipher = EVP_aes_192_ecb();
 384         break;
 385     case NID_aes_256_ctr:
 386         keylen = 32;
 387         ctr->cipher = EVP_aes_256_ecb();
 388         break;
 389     }
 390
 391     drbg->meth = &drbg_ctr_meth;
 392
 393     ctr->keylen = keylen;
 394     if (ctr->ctx == NULL)
 395         ctr->ctx = EVP_CIPHER_CTX_new();
 396     if (ctr->ctx == NULL)
 397         return 0;
 398     drbg->strength = keylen * 8;
 399     drbg->seedlen = keylen + 16;
 400
 401     if ((drbg->flags & RAND_DRBG_FLAG_CTR_NO_DF) == 0) {
 402         /* df initialisation */
 403         static const unsigned char df_key[32] = {
 404             0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 405             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 406             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 407             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
 408         };
 409
 410         if (ctr->ctx_df == NULL)
 411             ctr->ctx_df = EVP_CIPHER_CTX_new();
 412         if (ctr->ctx_df == NULL)
 413             return 0;
 414         /* Set key schedule for df_key */
 415         if (!EVP_CipherInit_ex(ctr->ctx_df, ctr->cipher, NULL, df_key, NULL, 1))
 416             return 0;
 417
 418         drbg->min_entropylen = ctr->keylen;
 419         drbg->max_entropylen = DRBG_MAX_LENGTH;
 420         drbg->min_noncelen = drbg->min_entropylen / 2;
 421         drbg->max_noncelen = DRBG_MAX_LENGTH;
 422         drbg->max_perslen = DRBG_MAX_LENGTH;
 423         drbg->max_adinlen = DRBG_MAX_LENGTH;
 424     } else {
 425 #ifdef FIPS_MODE
 426         RANDerr(RAND_F_DRBG_CTR_INIT,
 427                 RAND_R_DERIVATION_FUNCTION_MANDATORY_FOR_FIPS);
 428         return 0;
 429 #else
 430         drbg->min_entropylen = drbg->seedlen;
 431         drbg->max_entropylen = drbg->seedlen;
 432         /* Nonce not used */
 433         drbg->min_noncelen = 0;
 434         drbg->max_noncelen = 0;
 435         drbg->max_perslen = drbg->seedlen;
 436         drbg->max_adinlen = drbg->seedlen;
 437 #endif
 438     }
 439
 440     drbg->max_request = 1 << 16;
 441
 442     return 1;
 443 }