crypto/rand/drbg_ctr.c

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