Add support for KERN_ARND to get random bytes on NetBSD
[openssl.git] / 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 }