random: Remove the new API introduced by the new DRBG.
[libgcrypt.git] / random / drbg.c
1 /*
2  * DRBG: Deterministic Random Bits Generator
3  *       Based on NIST Recommended DRBG from NIST SP800-90A with the following
4  *       properties:
5  *              * CTR DRBG with DF with AES-128, AES-192, AES-256 cores
6  *              * Hash DRBG with DF with SHA-1, SHA-256, SHA-384, SHA-512 cores
7  *              * HMAC DRBG with DF with SHA-1, SHA-256, SHA-384, SHA-512 cores
8  *              * with and without prediction resistance
9  *
10  * Copyright Stephan Mueller <smueller@chronox.de>, 2014
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, and the entire permission notice in its entirety,
17  *    including the disclaimer of warranties.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. The name of the author may not be used to endorse or promote
22  *    products derived from this software without specific prior
23  *    written permission.
24  *
25  * ALTERNATIVELY, this product may be distributed under the terms of
26  * LGPLv2+, in which case the provisions of the LGPL are
27  * required INSTEAD OF the above restrictions.  (This clause is
28  * necessary due to a potential bad interaction between the LGPL and
29  * the restrictions contained in a BSD-style copyright.)
30  *
31  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
32  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
33  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
34  * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
35  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
36  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
37  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
38  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
39  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
40  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
41  * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
42  * DAMAGE.
43  *
44  *
45  * gcry_control GCRYCTL_DRBG_REINIT
46  * ================================
47  * This control request re-initializes the DRBG completely, i.e. the entire
48  * state of the DRBG is zeroized (with two exceptions listed in
49  * GCRYCTL_DRBG_SET_ENTROPY).
50  *
51  * The control request takes the following values which influences how
52  * the DRBG is re-initialized:
53  *
54  *  - const char *flagstr
55
56  *      This variable specifies the DRBG type to be used for the next
57  *      initialization.  If set to NULL, the previous DRBG type is
58  *      used for the initialization.  If not NULL a space separated
59  *      list of tokens with associated flag values is expected which
60  *      are ORed to form the mandatory flags of the requested DRBG
61  *      strength and cipher type.  Optionally, the prediction
62  *      resistance flag can be ORed into the flags variable.
63  *
64  *      | String token | Flag value             |
65  *      |--------------+------------------------|
66  *      | aes          | DRBG_CTRAES            |
67  *      | serpent      | DRBG_CTRSERPENT        |
68  *      | twofish      | DRBG_CTRTWOFISH        |
69  *      | sha1         | DRBG_HASHSHA1          |
70  *      | sha256       | DRBG_HASHSHA256        |
71  *      | sha512       | DRBG_HASHSHA512        |
72  *      | hmac         | DRBG_HMAC              |
73  *      | sym128       | DRBG_SYM128            |
74  *      | sym192       | DRBG_SYM192            |
75  *      | sym256       | DRBG_SYM256            |
76  *      | pr           | DRBG_PREDICTION_RESIST |
77  *
78  *    For example:
79  *
80  *      - CTR-DRBG with AES-128 without prediction resistance:
81  *          "aes sym128"
82  *      - HMAC-DRBG with SHA-512 with prediction resistance:
83  *          "hmac sha512 pr"
84  *
85  *  - gcry_buffer_t *pers
86  *
87  *      NULL terminated array with personalization strings to be used
88  *      for initialization.
89  *
90  *  - int npers
91  *
92  *     Size of PERS.
93  *
94  *  - void *guard
95  *
96  *      A value of NULL must be passed for this.
97  *
98  * The variable of flags is independent from the pers/perslen variables. If
99  * flags is set to 0 and perslen is set to 0, the current DRBG type is
100  * completely reset without using a personalization string.
101  *
102  * DRBG Usage
103  * ==========
104  * The SP 800-90A DRBG allows the user to specify a personalization string
105  * for initialization as well as an additional information string for each
106  * random number request.  The following code fragments show how a caller
107  * uses the API to use the full functionality of the DRBG.
108  *
109  * Usage without any additional data
110  * ---------------------------------
111  * gcry_randomize(outbuf, OUTLEN, GCRY_STRONG_RANDOM);
112  *
113  *
114  * Usage with personalization string during initialization
115  * -------------------------------------------------------
116  * struct gcry_drbg_string pers;
117  * char personalization[11] = "some-string";
118  *
119  * gcry_drbg_string_fill(&pers, personalization, strlen(personalization));
120  * // The reset completely re-initializes the DRBG with the provided
121  * // personalization string without changing the DRBG type
122  * ret = gcry_control(GCRYCTL_DRBG_REINIT, 0, &pers);
123  * gcry_randomize(outbuf, OUTLEN, GCRY_STRONG_RANDOM);
124  *
125  *
126  * Usage with additional information string during random number request
127  * ---------------------------------------------------------------------
128  * struct gcry_drbg_string addtl;
129  * char addtl_string[11] = "some-string";
130  *
131  * gcry_drbg_string_fill(&addtl, addtl_string, strlen(addtl_string));
132  * // The following call is a wrapper to gcry_randomize() and returns
133  * // the same error codes.
134  * gcry_randomize_drbg(outbuf, OUTLEN, GCRY_STRONG_RANDOM, &addtl);
135  *
136  *
137  * Usage with personalization and additional information strings
138  * -------------------------------------------------------------
139  * Just mix both scenarios above.
140  *
141  *
142  * Switch the DRBG type to some other type
143  * ---------------------------------------
144  * // Switch to CTR DRBG AES-128 without prediction resistance
145  * ret = gcry_control(GCRYCTL_DRBG_REINIT, DRBG_NOPR_CTRAES128, NULL);
146  * gcry_randomize(outbuf, OUTLEN, GCRY_STRONG_RANDOM);
147  */
148
149 #include <sys/types.h>
150 #include <asm/types.h>
151 #include <string.h>
152 #include <unistd.h>
153 #include <stdint.h>
154
155 #include <config.h>
156
157 #include "g10lib.h"
158 #include "random.h"
159 #include "rand-internal.h"
160 #include "../cipher/bithelp.h"
161
162
163 \f
164 /******************************************************************
165  * Constants
166  ******************************************************************/
167
168 /*
169  * DRBG flags bitmasks
170  *
171  * 31 (B) 28      19         (A)         0
172  *  +-+-+-+--------+---+-----------+-----+
173  *  |~|~|u|~~~~~~~~| 3 |     2     |  1  |
174  *  +-+-+-+--------+- -+-----------+-----+
175  * ctl flg|        |drbg use selection flags
176  *
177  */
178
179 /* Internal state control flags (B) */
180 #define GCRY_DRBG_PREDICTION_RESIST     ((u_int32_t)1<<28)
181
182 /* CTR type modifiers (A.1)*/
183 #define GCRY_DRBG_CTRAES                ((u_int32_t)1<<0)
184 #define GCRY_DRBG_CTRSERPENT            ((u_int32_t)1<<1)
185 #define GCRY_DRBG_CTRTWOFISH            ((u_int32_t)1<<2)
186 #define GCRY_DRBG_CTR_MASK      (GCRY_DRBG_CTRAES | GCRY_DRBG_CTRSERPENT | GCRY_DRBG_CTRTWOFISH)
187
188 /* HASH type modifiers (A.2)*/
189 #define GCRY_DRBG_HASHSHA1              ((u_int32_t)1<<4)
190 #define GCRY_DRBG_HASHSHA224            ((u_int32_t)1<<5)
191 #define GCRY_DRBG_HASHSHA256            ((u_int32_t)1<<6)
192 #define GCRY_DRBG_HASHSHA384            ((u_int32_t)1<<7)
193 #define GCRY_DRBG_HASHSHA512            ((u_int32_t)1<<8)
194 #define GCRY_DRBG_HASH_MASK             (GCRY_DRBG_HASHSHA1 | GCRY_DRBG_HASHSHA224 | \
195                                  GCRY_DRBG_HASHSHA256 | GCRY_DRBG_HASHSHA384 | \
196                                  GCRY_DRBG_HASHSHA512)
197 /* type modifiers (A.3)*/
198 #define GCRY_DRBG_HMAC          ((u_int32_t)1<<12)
199 #define GCRY_DRBG_SYM128                ((u_int32_t)1<<13)
200 #define GCRY_DRBG_SYM192                ((u_int32_t)1<<14)
201 #define GCRY_DRBG_SYM256                ((u_int32_t)1<<15)
202 #define GCRY_DRBG_TYPE_MASK             (GCRY_DRBG_HMAC | GCRY_DRBG_SYM128 | GCRY_DRBG_SYM192 | \
203                                  GCRY_DRBG_SYM256)
204 #define GCRY_DRBG_CIPHER_MASK (GCRY_DRBG_CTR_MASK | GCRY_DRBG_HASH_MASK | GCRY_DRBG_TYPE_MASK)
205
206 #define GCRY_DRBG_PR_CTRAES128   (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_CTRAES | GCRY_DRBG_SYM128)
207 #define GCRY_DRBG_PR_CTRAES192   (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_CTRAES | GCRY_DRBG_SYM192)
208 #define GCRY_DRBG_PR_CTRAES256   (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_CTRAES | GCRY_DRBG_SYM256)
209 #define GCRY_DRBG_NOPR_CTRAES128 (GCRY_DRBG_CTRAES | GCRY_DRBG_SYM128)
210 #define GCRY_DRBG_NOPR_CTRAES192 (GCRY_DRBG_CTRAES | GCRY_DRBG_SYM192)
211 #define GCRY_DRBG_NOPR_CTRAES256 (GCRY_DRBG_CTRAES | GCRY_DRBG_SYM256)
212 #define GCRY_DRBG_PR_HASHSHA1    (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_HASHSHA1)
213 #define GCRY_DRBG_PR_HASHSHA256  (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_HASHSHA256)
214 #define GCRY_DRBG_PR_HASHSHA384  (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_HASHSHA384)
215 #define GCRY_DRBG_PR_HASHSHA512  (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_HASHSHA512)
216 #define GCRY_DRBG_NOPR_HASHSHA1  (GCRY_DRBG_HASHSHA1)
217 #define GCRY_DRBG_NOPR_HASHSHA256 (GCRY_DRBG_HASHSHA256)
218 #define GCRY_DRBG_NOPR_HASHSHA384 (GCRY_DRBG_HASHSHA384)
219 #define GCRY_DRBG_NOPR_HASHSHA512 (GCRY_DRBG_HASHSHA512)
220 #define GCRY_DRBG_PR_HMACSHA1    (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_HASHSHA1 | GCRY_DRBG_HMAC)
221 #define GCRY_DRBG_PR_HMACSHA256  (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_HASHSHA256 | GCRY_DRBG_HMAC)
222 #define GCRY_DRBG_PR_HMACSHA384  (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_HASHSHA384 | GCRY_DRBG_HMAC)
223 #define GCRY_DRBG_PR_HMACSHA512  (GCRY_DRBG_PREDICTION_RESIST | GCRY_DRBG_HASHSHA512 | GCRY_DRBG_HMAC)
224 #define GCRY_DRBG_NOPR_HMACSHA1  (GCRY_DRBG_HASHSHA1 | GCRY_DRBG_HMAC)
225 #define GCRY_DRBG_NOPR_HMACSHA256 (GCRY_DRBG_HASHSHA256 | GCRY_DRBG_HMAC)
226 #define GCRY_DRBG_NOPR_HMACSHA384 (GCRY_DRBG_HASHSHA384 | GCRY_DRBG_HMAC)
227 #define GCRY_DRBG_NOPR_HMACSHA512 (GCRY_DRBG_HASHSHA512 | GCRY_DRBG_HMAC)
228
229
230 \f
231 /******************************************************************
232  * Common data structures
233  ******************************************************************/
234
235 /* DRBG input data structure for DRBG generate with additional information
236  * string */
237 struct gcry_drbg_gen
238 {
239   unsigned char *outbuf;        /* output buffer for random numbers */
240   unsigned int outlen;  /* size of output buffer */
241   struct gcry_drbg_string *addtl;       /* input buffer for
242                                          * additional information string */
243 };
244
245
246 /*
247  * SP800-90A requires the concatenation of different data. To avoid copying
248  * buffers around or allocate additional memory, the following data structure
249  * is used to point to the original memory with its size. In addition, it
250  * is used to build a linked list. The linked list defines the concatenation
251  * of individual buffers. The order of memory block referenced in that
252  * linked list determines the order of concatenation.
253  */
254 struct gcry_drbg_string
255 {
256   const unsigned char *buf;
257   size_t len;
258   struct gcry_drbg_string *next;
259 };
260
261
262 /* (Declared below) */
263 struct gcry_drbg_state;
264
265 struct gcry_drbg_core
266 {
267   u32 flags;                    /* flags for the cipher */
268   ushort statelen;              /* maximum state length */
269   ushort blocklen_bytes;        /* block size of output in bytes */
270   int backend_cipher;           /* libgcrypt backend cipher */
271 };
272
273 struct gcry_drbg_state_ops
274 {
275   gpg_err_code_t (*update) (struct gcry_drbg_state * drbg,
276                             struct gcry_drbg_string * seed, int reseed);
277   gpg_err_code_t (*generate) (struct gcry_drbg_state * drbg,
278                               unsigned char *buf, unsigned int buflen,
279                               struct gcry_drbg_string * addtl);
280 };
281
282 /* DRBG test data */
283 struct gcry_drbg_test_data
284 {
285   struct gcry_drbg_string *testentropy; /* TEST PARAMETER: test entropy */
286   int fail_seed_source:1;       /* if set, the seed function will return an error */
287 };
288
289
290 struct gcry_drbg_state
291 {
292   unsigned char *V;             /* internal state 10.1.1.1 1a) */
293   unsigned char *C;             /* hash: static value 10.1.1.1 1b)
294                                  * hmac / ctr: key */
295   size_t reseed_ctr;            /* Number of RNG requests since last reseed --
296                                  * 10.1.1.1 1c) */
297   unsigned char *scratchpad;    /* some memory the DRBG can use for its
298                                  * operation -- allocated during init */
299   int seeded:1;                 /* DRBG fully seeded? */
300   int pr:1;                     /* Prediction resistance enabled? */
301   /* Taken from libgcrypt ANSI X9.31 DRNG: We need to keep track of the
302    * process which did the initialization so that we can detect a fork.
303    * The volatile modifier is required so that the compiler does not
304    * optimize it away in case the getpid function is badly attributed. */
305   pid_t seed_init_pid;
306   const struct gcry_drbg_state_ops *d_ops;
307   const struct gcry_drbg_core *core;
308   struct gcry_drbg_test_data *test_data;
309 };
310
311 enum gcry_drbg_prefixes
312 {
313   DRBG_PREFIX0 = 0x00,
314   DRBG_PREFIX1,
315   DRBG_PREFIX2,
316   DRBG_PREFIX3
317 };
318
319 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
320
321 /***************************************************************
322  * Backend cipher definitions available to DRBG
323  ***************************************************************/
324
325 static const struct gcry_drbg_core gcry_drbg_cores[] = {
326   /* Hash DRBGs */
327   {GCRY_DRBG_HASHSHA1, 55, 20, GCRY_MD_SHA1},
328   {GCRY_DRBG_HASHSHA256, 55, 32, GCRY_MD_SHA256},
329   {GCRY_DRBG_HASHSHA384, 111, 48, GCRY_MD_SHA384},
330   {GCRY_DRBG_HASHSHA512, 111, 64, GCRY_MD_SHA512},
331   /* HMAC DRBGs */
332   {GCRY_DRBG_HASHSHA1 | GCRY_DRBG_HMAC, 20, 20, GCRY_MD_SHA1},
333   {GCRY_DRBG_HASHSHA256 | GCRY_DRBG_HMAC, 32, 32, GCRY_MD_SHA256},
334   {GCRY_DRBG_HASHSHA384 | GCRY_DRBG_HMAC, 48, 48, GCRY_MD_SHA384},
335   {GCRY_DRBG_HASHSHA512 | GCRY_DRBG_HMAC, 64, 64, GCRY_MD_SHA512},
336   /* block ciphers */
337   {GCRY_DRBG_CTRAES | GCRY_DRBG_SYM128, 32, 16, GCRY_CIPHER_AES128},
338   {GCRY_DRBG_CTRAES | GCRY_DRBG_SYM192, 40, 16, GCRY_CIPHER_AES192},
339   {GCRY_DRBG_CTRAES | GCRY_DRBG_SYM256, 48, 16, GCRY_CIPHER_AES256},
340 };
341
342 static gpg_err_code_t gcry_drbg_sym (struct gcry_drbg_state *drbg,
343                                      const unsigned char *key,
344                                      unsigned char *outval,
345                                      const struct gcry_drbg_string *buf);
346 static gpg_err_code_t gcry_drbg_hmac (struct gcry_drbg_state *drbg,
347                                       const unsigned char *key,
348                                       unsigned char *outval,
349                                       const struct gcry_drbg_string *buf);
350
351 /******************************************************************
352  ******************************************************************
353  ******************************************************************
354  * Generic DRBG code
355  ******************************************************************
356  ******************************************************************
357  ******************************************************************/
358
359 /******************************************************************
360  * Generic helper functions
361  ******************************************************************/
362
363 #if 0
364 #define dbg(x) do { log_debug x; } while(0)
365 #else
366 #define dbg(x)
367 #endif
368
369 /*
370  * Parse a string of flags and store the flag values at R_FLAGS.
371  * Return 0 on success.
372  */
373 static gpg_err_code_t
374 parse_flag_string (const char *string, u32 *r_flags)
375 {
376   struct {
377     const char *name;
378     u32 flag;
379   } table[] = {
380     { "aes",     GCRY_DRBG_CTRAES            },
381     { "serpent", GCRY_DRBG_CTRSERPENT        },
382     { "twofish", GCRY_DRBG_CTRTWOFISH        },
383     { "sha1",    GCRY_DRBG_HASHSHA1          },
384     { "sha256",  GCRY_DRBG_HASHSHA256        },
385     { "sha512",  GCRY_DRBG_HASHSHA512        },
386     { "hmac",    GCRY_DRBG_HMAC              },
387     { "sym128",  GCRY_DRBG_SYM128            },
388     { "sym192",  GCRY_DRBG_SYM192            },
389     { "sym256",  GCRY_DRBG_SYM256            },
390     { "pr",      GCRY_DRBG_PREDICTION_RESIST }
391   };
392
393   *r_flags = 0;
394   if (string)
395     {
396       char **tl;
397       const char *s;
398       int i, j;
399
400       tl = _gcry_strtokenize (string, NULL);
401       if (!tl)
402         return gpg_err_code_from_syserror ();
403       for (i=0; (s=tl[i]); i++)
404         {
405           for (j=0; j < DIM (table); j++)
406             if (!strcmp (s, table[j].name))
407               {
408                 *r_flags |= table[j].flag;
409                 break;
410               }
411           if (!(j < DIM (table)))
412             {
413               xfree (tl);
414               return GPG_ERR_INV_FLAG;
415             }
416         }
417       xfree (tl);
418     }
419
420   return 0;
421 }
422
423 static inline void
424 gcry_drbg_string_fill (struct gcry_drbg_string *string,
425                        const unsigned char *buf, size_t len)
426 {
427   string->buf = buf;
428   string->len = len;
429   string->next = NULL;
430 }
431
432 static inline ushort
433 gcry_drbg_statelen (struct gcry_drbg_state *drbg)
434 {
435   if (drbg && drbg->core)
436     return drbg->core->statelen;
437   return 0;
438 }
439
440 static inline ushort
441 gcry_drbg_blocklen (struct gcry_drbg_state *drbg)
442 {
443   if (drbg && drbg->core)
444     return drbg->core->blocklen_bytes;
445   return 0;
446 }
447
448 static inline ushort
449 gcry_drbg_keylen (struct gcry_drbg_state *drbg)
450 {
451   if (drbg && drbg->core)
452     return (drbg->core->statelen - drbg->core->blocklen_bytes);
453   return 0;
454 }
455
456 static inline size_t
457 gcry_drbg_max_request_bytes (void)
458 {
459   /* SP800-90A requires the limit 2**19 bits, but we return bytes */
460   return (1 << 16);
461 }
462
463 static inline size_t
464 gcry_drbg_max_addtl (void)
465 {
466   /* SP800-90A requires 2**35 bytes additional info str / pers str */
467 #ifdef __LP64__
468   return (1UL << 35);
469 #else
470   /*
471    * SP800-90A allows smaller maximum numbers to be returned -- we
472    * return SIZE_MAX - 1 to allow the verification of the enforcement
473    * of this value in gcry_drbg_healthcheck_sanity.
474    */
475   return (SIZE_MAX - 1);
476 #endif
477 }
478
479 static inline size_t
480 gcry_drbg_max_requests (void)
481 {
482   /* SP800-90A requires 2**48 maximum requests before reseeding */
483 #ifdef __LP64__
484   return (1UL << 48);
485 #else
486   return SIZE_MAX;
487 #endif
488 }
489
490 /*
491  * Return strength of DRBG according to SP800-90A section 8.4
492  *
493  * flags: DRBG flags reference
494  *
495  * Return: normalized strength value or 32 as a default to counter
496  *         programming errors
497  */
498 static inline unsigned short
499 gcry_drbg_sec_strength (u32 flags)
500 {
501   if ((flags & GCRY_DRBG_HASHSHA1) || (flags & GCRY_DRBG_SYM128))
502     return 16;
503   else if (flags & GCRY_DRBG_SYM192)
504     return 24;
505   else if ((flags & GCRY_DRBG_SYM256) || (flags & GCRY_DRBG_HASHSHA256) ||
506            (flags & GCRY_DRBG_HASHSHA384) || (flags & GCRY_DRBG_HASHSHA512))
507     return 32;
508   else
509     return 32;
510 }
511
512 /*
513  * Convert an integer into a byte representation of this integer.
514  * The byte representation is big-endian
515  *
516  * @val value to be converted
517  * @buf buffer holding the converted integer -- caller must ensure that
518  *      buffer size is at least 32 bit
519  */
520 static inline void
521 gcry_drbg_cpu_to_be32 (u32 val, unsigned char *buf)
522 {
523   struct s
524   {
525     u32 conv;
526   };
527   struct s *conversion = (struct s *) buf;
528
529   conversion->conv = be_bswap32 (val);
530 }
531
532 static void
533 gcry_drbg_add_buf (unsigned char *dst, size_t dstlen,
534                    unsigned char *add, size_t addlen)
535 {
536   /* implied: dstlen > addlen */
537   unsigned char *dstptr, *addptr;
538   unsigned int remainder = 0;
539   size_t len = addlen;
540
541   dstptr = dst + (dstlen - 1);
542   addptr = add + (addlen - 1);
543   while (len)
544     {
545       remainder += *dstptr + *addptr;
546       *dstptr = remainder & 0xff;
547       remainder >>= 8;
548       len--;
549       dstptr--;
550       addptr--;
551     }
552   len = dstlen - addlen;
553   while (len && remainder > 0)
554     {
555       remainder = *dstptr + 1;
556       *dstptr = remainder & 0xff;
557       remainder >>= 8;
558       len--;
559       dstptr--;
560     }
561 }
562
563 /* Helper variables for read_cb().
564  *
565  *   The _gcry_rnd*_gather_random interface does not allow to provide a
566  *   data pointer.  Thus we need to use a global variable for
567  *   communication.  However, the then required locking is anyway a good
568  *   idea because it does not make sense to have several readers of (say
569  *   /dev/random).  It is easier to serve them one after the other.  */
570 static unsigned char *read_cb_buffer;   /* The buffer.  */
571 static size_t read_cb_size;     /* Size of the buffer.  */
572 static size_t read_cb_len;      /* Used length.  */
573
574 /* Callback for generating seed from kernel device. */
575 static void
576 gcry_drbg_read_cb (const void *buffer, size_t length,
577                    enum random_origins origin)
578 {
579   const unsigned char *p = buffer;
580
581   (void) origin;
582   gcry_assert (read_cb_buffer);
583
584   /* Note that we need to protect against gatherers returning more
585    * than the requested bytes (e.g. rndw32).  */
586   while (length-- && read_cb_len < read_cb_size)
587     read_cb_buffer[read_cb_len++] = *p++;
588 }
589
590 static inline int
591 gcry_drbg_get_entropy (struct gcry_drbg_state *drbg, unsigned char *buffer,
592                        size_t len)
593 {
594   int rc = 0;
595
596   /* Perform testing as defined in 11.3.2 */
597   if (drbg->test_data && drbg->test_data->fail_seed_source)
598     return -1;
599
600   read_cb_buffer = buffer;
601   read_cb_size = len;
602   read_cb_len = 0;
603 #if USE_RNDLINUX
604   rc = _gcry_rndlinux_gather_random (gcry_drbg_read_cb, 0, len,
605                                      GCRY_VERY_STRONG_RANDOM);
606 #elif USE_RNDUNIX
607   rc = _gcry_rndunix_gather_random (read_cb, 0, length,
608                                     GCRY_VERY_STRONG_RANDOM);
609 #elif USE_RNDW32
610   do
611     {
612       rc = _gcry_rndw32_gather_random (read_cb, 0, length,
613                                        GCRY_VERY_STRONG_RANDOM);
614     }
615   while (rc >= 0 && read_cb_len < read_cb_size);
616 #else
617   rc = -1;
618 #endif
619   return rc;
620 }
621
622 /******************************************************************
623  * CTR DRBG callback functions
624  ******************************************************************/
625
626 /* BCC function for CTR DRBG as defined in 10.4.3 */
627 static gpg_err_code_t
628 gcry_drbg_ctr_bcc (struct gcry_drbg_state *drbg,
629                    unsigned char *out, const unsigned char *key,
630                    struct gcry_drbg_string *in)
631 {
632   gpg_err_code_t ret = GPG_ERR_GENERAL;
633   struct gcry_drbg_string *curr = in;
634   size_t inpos = curr->len;
635   const unsigned char *pos = curr->buf;
636   struct gcry_drbg_string data;
637
638   gcry_drbg_string_fill (&data, out, gcry_drbg_blocklen (drbg));
639
640   /* 10.4.3 step 1 */
641   memset (out, 0, gcry_drbg_blocklen (drbg));
642
643   /* 10.4.3 step 2 / 4 */
644   while (inpos)
645     {
646       short cnt = 0;
647       /* 10.4.3 step 4.1 */
648       for (cnt = 0; cnt < gcry_drbg_blocklen (drbg); cnt++)
649         {
650           out[cnt] ^= *pos;
651           pos++;
652           inpos--;
653           /* the following branch implements the linked list
654            * iteration. If we are at the end of the current data
655            * set, we have to start using the next data set if
656            * available -- the inpos value always points to the
657            * current byte and will be zero if we have processed
658            * the last byte of the last linked list member */
659           if (0 == inpos)
660             {
661               curr = curr->next;
662               if (NULL != curr)
663                 {
664                   pos = curr->buf;
665                   inpos = curr->len;
666                 }
667               else
668                 {
669                   inpos = 0;
670                   break;
671                 }
672             }
673         }
674       /* 10.4.3 step 4.2 */
675       ret = gcry_drbg_sym (drbg, key, out, &data);
676       if (ret)
677         return ret;
678       /* 10.4.3 step 2 */
679     }
680   return 0;
681 }
682
683
684 /*
685  * scratchpad usage: gcry_drbg_ctr_update is interlinked with gcry_drbg_ctr_df
686  * (and gcry_drbg_ctr_bcc, but this function does not need any temporary buffers),
687  * the scratchpad is used as follows:
688  * gcry_drbg_ctr_update:
689  *      temp
690  *              start: drbg->scratchpad
691  *              length: gcry_drbg_statelen(drbg) + gcry_drbg_blocklen(drbg)
692  *                      note: the cipher writing into this variable works
693  *                      blocklen-wise. Now, when the statelen is not a multiple
694  *                      of blocklen, the generateion loop below "spills over"
695  *                      by at most blocklen. Thus, we need to give sufficient
696  *                      memory.
697  *      df_data
698  *              start: drbg->scratchpad +
699  *                              gcry_drbg_statelen(drbg) +
700  *                              gcry_drbg_blocklen(drbg)
701  *              length: gcry_drbg_statelen(drbg)
702  *
703  * gcry_drbg_ctr_df:
704  *      pad
705  *              start: df_data + gcry_drbg_statelen(drbg)
706  *              length: gcry_drbg_blocklen(drbg)
707  *      iv
708  *              start: pad + gcry_drbg_blocklen(drbg)
709  *              length: gcry_drbg_blocklen(drbg)
710  *      temp
711  *              start: iv + gcry_drbg_blocklen(drbg)
712  *              length: gcry_drbg_satelen(drbg) + gcry_drbg_blocklen(drbg)
713  *                      note: temp is the buffer that the BCC function operates
714  *                      on. BCC operates blockwise. gcry_drbg_statelen(drbg)
715  *                      is sufficient when the DRBG state length is a multiple
716  *                      of the block size. For AES192 (and maybe other ciphers)
717  *                      this is not correct and the length for temp is
718  *                      insufficient (yes, that also means for such ciphers,
719  *                      the final output of all BCC rounds are truncated).
720  *                      Therefore, add gcry_drbg_blocklen(drbg) to cover all
721  *                      possibilities.
722  */
723
724 /* Derivation Function for CTR DRBG as defined in 10.4.2 */
725 static gpg_err_code_t
726 gcry_drbg_ctr_df (struct gcry_drbg_state *drbg, unsigned char *df_data,
727                   size_t bytes_to_return, struct gcry_drbg_string *addtl)
728 {
729   gpg_err_code_t ret = GPG_ERR_GENERAL;
730   unsigned char L_N[8];
731   /* S3 is input */
732   struct gcry_drbg_string S1, S2, S4, cipherin;
733   struct gcry_drbg_string *tempstr = addtl;
734   unsigned char *pad = df_data + gcry_drbg_statelen (drbg);
735   unsigned char *iv = pad + gcry_drbg_blocklen (drbg);
736   unsigned char *temp = iv + gcry_drbg_blocklen (drbg);
737   size_t padlen = 0;
738   unsigned int templen = 0;
739   /* 10.4.2 step 7 */
740   unsigned int i = 0;
741   /* 10.4.2 step 8 */
742   const unsigned char *K = (unsigned char *)
743     "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
744     "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f";
745   unsigned char *X;
746   size_t generated_len = 0;
747   size_t inputlen = 0;
748
749   memset (pad, 0, gcry_drbg_blocklen (drbg));
750   memset (iv, 0, gcry_drbg_blocklen (drbg));
751   memset (temp, 0, gcry_drbg_statelen (drbg));
752
753   /* 10.4.2 step 1 is implicit as we work byte-wise */
754
755   /* 10.4.2 step 2 */
756   if ((512 / 8) < bytes_to_return)
757     return GPG_ERR_INV_ARG;
758
759   /* 10.4.2 step 2 -- calculate the entire length of all input data */
760   for (; NULL != tempstr; tempstr = tempstr->next)
761     inputlen += tempstr->len;
762   gcry_drbg_cpu_to_be32 (inputlen, &L_N[0]);
763
764   /* 10.4.2 step 3 */
765   gcry_drbg_cpu_to_be32 (bytes_to_return, &L_N[4]);
766
767   /* 10.4.2 step 5: length is size of L_N, input_string, one byte, padding */
768   padlen = (inputlen + sizeof (L_N) + 1) % (gcry_drbg_blocklen (drbg));
769   /* wrap the padlen appropriately */
770   if (padlen)
771     padlen = gcry_drbg_blocklen (drbg) - padlen;
772   /* pad / padlen contains the 0x80 byte and the following zero bytes, so
773    * add one for byte for 0x80 */
774   padlen++;
775   pad[0] = 0x80;
776
777   /* 10.4.2 step 4 -- first fill the linked list and then order it */
778   gcry_drbg_string_fill (&S1, iv, gcry_drbg_blocklen (drbg));
779   gcry_drbg_string_fill (&S2, L_N, sizeof (L_N));
780   gcry_drbg_string_fill (&S4, pad, padlen);
781   S1.next = &S2;
782   S2.next = addtl;
783
784   /* Splice in addtl between S2 and S4 -- we place S4 at the end of the
785    * input data chain. As this code is only triggered when addtl is not
786    * NULL, no NULL checks are necessary.*/
787   tempstr = addtl;
788   while (tempstr->next)
789     tempstr = tempstr->next;
790   tempstr->next = &S4;
791
792   /* 10.4.2 step 9 */
793   while (templen < (gcry_drbg_keylen (drbg) + (gcry_drbg_blocklen (drbg))))
794     {
795       /* 10.4.2 step 9.1 - the padding is implicit as the buffer
796        * holds zeros after allocation -- even the increment of i
797        * is irrelevant as the increment remains within length of i */
798       gcry_drbg_cpu_to_be32 (i, iv);
799       /* 10.4.2 step 9.2 -- BCC and concatenation with temp */
800       ret = gcry_drbg_ctr_bcc (drbg, temp + templen, K, &S1);
801       if (ret)
802         goto out;
803       /* 10.4.2 step 9.3 */
804       i++;
805       templen += gcry_drbg_blocklen (drbg);
806     }
807
808   /* 10.4.2 step 11 */
809   /* implicit key len with seedlen - blocklen according to table 3 */
810   X = temp + (gcry_drbg_keylen (drbg));
811   gcry_drbg_string_fill (&cipherin, X, gcry_drbg_blocklen (drbg));
812
813   /* 10.4.2 step 12: overwriting of outval */
814
815   /* 10.4.2 step 13 */
816   while (generated_len < bytes_to_return)
817     {
818       short blocklen = 0;
819       /* 10.4.2 step 13.1 */
820       /* the truncation of the key length is implicit as the key
821        * is only gcry_drbg_blocklen in size -- check for the implementation
822        * of the cipher function callback */
823       ret = gcry_drbg_sym (drbg, temp, X, &cipherin);
824       if (ret)
825         goto out;
826       blocklen = (gcry_drbg_blocklen (drbg) <
827                   (bytes_to_return - generated_len)) ?
828         gcry_drbg_blocklen (drbg) : (bytes_to_return - generated_len);
829       /* 10.4.2 step 13.2 and 14 */
830       memcpy (df_data + generated_len, X, blocklen);
831       generated_len += blocklen;
832     }
833
834   ret = 0;
835
836 out:
837   memset (iv, 0, gcry_drbg_blocklen (drbg));
838   memset (temp, 0, gcry_drbg_statelen (drbg));
839   memset (pad, 0, gcry_drbg_blocklen (drbg));
840   return ret;
841 }
842
843 /*
844  * update function of CTR DRBG as defined in 10.2.1.2
845  *
846  * The reseed variable has an enhanced meaning compared to the update
847  * functions of the other DRBGs as follows:
848  * 0 => initial seed from initialization
849  * 1 => reseed via gcry_drbg_seed
850  * 2 => first invocation from gcry_drbg_ctr_update when addtl is present. In
851  *      this case, the df_data scratchpad is not deleted so that it is
852  *      available for another calls to prevent calling the DF function
853  *      again.
854  * 3 => second invocation from gcry_drbg_ctr_update. When the update function
855  *      was called with addtl, the df_data memory already contains the
856  *      DFed addtl information and we do not need to call DF again.
857  */
858 static gpg_err_code_t
859 gcry_drbg_ctr_update (struct gcry_drbg_state *drbg,
860                       struct gcry_drbg_string *addtl, int reseed)
861 {
862   gpg_err_code_t ret = GPG_ERR_GENERAL;
863   /* 10.2.1.2 step 1 */
864   unsigned char *temp = drbg->scratchpad;
865   unsigned char *df_data = drbg->scratchpad +
866     gcry_drbg_statelen (drbg) + gcry_drbg_blocklen (drbg);
867   unsigned char *temp_p, *df_data_p;    /* pointer to iterate over buffers */
868   unsigned int len = 0;
869   struct gcry_drbg_string cipherin;
870   unsigned char prefix = DRBG_PREFIX1;
871
872   memset (temp, 0, gcry_drbg_statelen (drbg) + gcry_drbg_blocklen (drbg));
873   if (3 > reseed)
874     memset (df_data, 0, gcry_drbg_statelen (drbg));
875
876   /* 10.2.1.3.2 step 2 and 10.2.1.4.2 step 2 */
877   /* TODO use reseed variable to avoid re-doing DF operation */
878   (void) reseed;
879   if (addtl && 0 < addtl->len)
880     {
881       ret =
882         gcry_drbg_ctr_df (drbg, df_data, gcry_drbg_statelen (drbg), addtl);
883       if (ret)
884         goto out;
885     }
886
887   gcry_drbg_string_fill (&cipherin, drbg->V, gcry_drbg_blocklen (drbg));
888   /* 10.2.1.3.2 step 2 and 3 -- are already covered as we memset(0)
889    * all memory during initialization */
890   while (len < (gcry_drbg_statelen (drbg)))
891     {
892       /* 10.2.1.2 step 2.1 */
893       gcry_drbg_add_buf (drbg->V, gcry_drbg_blocklen (drbg), &prefix, 1);
894       /* 10.2.1.2 step 2.2 */
895       /* using target of temp + len: 10.2.1.2 step 2.3 and 3 */
896       ret = gcry_drbg_sym (drbg, drbg->C, temp + len, &cipherin);
897       if (ret)
898         goto out;
899       /* 10.2.1.2 step 2.3 and 3 */
900       len += gcry_drbg_blocklen (drbg);
901     }
902
903   /* 10.2.1.2 step 4 */
904   temp_p = temp;
905   df_data_p = df_data;
906   for (len = 0; len < gcry_drbg_statelen (drbg); len++)
907     {
908       *temp_p ^= *df_data_p;
909       df_data_p++;
910       temp_p++;
911     }
912
913   /* 10.2.1.2 step 5 */
914   memcpy (drbg->C, temp, gcry_drbg_keylen (drbg));
915   /* 10.2.1.2 step 6 */
916   memcpy (drbg->V, temp + gcry_drbg_keylen (drbg), gcry_drbg_blocklen (drbg));
917   ret = 0;
918
919 out:
920   memset (temp, 0, gcry_drbg_statelen (drbg) + gcry_drbg_blocklen (drbg));
921   if (2 != reseed)
922     memset (df_data, 0, gcry_drbg_statelen (drbg));
923   return ret;
924 }
925
926 /*
927  * scratchpad use: gcry_drbg_ctr_update is called independently from
928  * gcry_drbg_ctr_extract_bytes. Therefore, the scratchpad is reused
929  */
930 /* Generate function of CTR DRBG as defined in 10.2.1.5.2 */
931 static gpg_err_code_t
932 gcry_drbg_ctr_generate (struct gcry_drbg_state *drbg,
933                         unsigned char *buf, unsigned int buflen,
934                         struct gcry_drbg_string *addtl)
935 {
936   gpg_err_code_t ret = 0;
937   unsigned int len = 0;
938   struct gcry_drbg_string data;
939   unsigned char prefix = DRBG_PREFIX1;
940
941   memset (drbg->scratchpad, 0, gcry_drbg_blocklen (drbg));
942
943   /* 10.2.1.5.2 step 2 */
944   if (addtl && 0 < addtl->len)
945     {
946       addtl->next = NULL;
947       ret = gcry_drbg_ctr_update (drbg, addtl, 2);
948       if (ret)
949         return ret;
950     }
951
952   /* 10.2.1.5.2 step 4.1 */
953   gcry_drbg_add_buf (drbg->V, gcry_drbg_blocklen (drbg), &prefix, 1);
954   gcry_drbg_string_fill (&data, drbg->V, gcry_drbg_blocklen (drbg));
955   while (len < buflen)
956     {
957       unsigned int outlen = 0;
958       /* 10.2.1.5.2 step 4.2 */
959       ret = gcry_drbg_sym (drbg, drbg->C, drbg->scratchpad, &data);
960       if (ret)
961         goto out;
962       outlen = (gcry_drbg_blocklen (drbg) < (buflen - len)) ?
963         gcry_drbg_blocklen (drbg) : (buflen - len);
964       /* 10.2.1.5.2 step 4.3 */
965       memcpy (buf + len, drbg->scratchpad, outlen);
966       len += outlen;
967       /* 10.2.1.5.2 step 6 */
968       if (len < buflen)
969         gcry_drbg_add_buf (drbg->V, gcry_drbg_blocklen (drbg), &prefix, 1);
970     }
971
972   /* 10.2.1.5.2 step 6 */
973   if (addtl)
974     addtl->next = NULL;
975   ret = gcry_drbg_ctr_update (drbg, addtl, 3);
976
977 out:
978   memset (drbg->scratchpad, 0, gcry_drbg_blocklen (drbg));
979   return ret;
980 }
981
982 static struct gcry_drbg_state_ops gcry_drbg_ctr_ops = {
983   gcry_drbg_ctr_update,
984   gcry_drbg_ctr_generate,
985 };
986
987 /******************************************************************
988  * HMAC DRBG callback functions
989  ******************************************************************/
990
991 static gpg_err_code_t
992 gcry_drbg_hmac_update (struct gcry_drbg_state *drbg,
993                        struct gcry_drbg_string *seed, int reseed)
994 {
995   gpg_err_code_t ret = GPG_ERR_GENERAL;
996   int i = 0;
997   struct gcry_drbg_string seed1, seed2, cipherin;
998
999   if (!reseed)
1000     /* 10.1.2.3 step 2 already implicitly covered with
1001      * the initial memset(0) of drbg->C */
1002     memset (drbg->V, 1, gcry_drbg_statelen (drbg));
1003
1004   /* build linked list which implements the concatenation and fill
1005    * first part*/
1006   gcry_drbg_string_fill (&seed1, drbg->V, gcry_drbg_statelen (drbg));
1007   /* buffer will be filled in for loop below with one byte */
1008   gcry_drbg_string_fill (&seed2, NULL, 1);
1009   seed1.next = &seed2;
1010   /* seed may be NULL */
1011   seed2.next = seed;
1012
1013   gcry_drbg_string_fill (&cipherin, drbg->V, gcry_drbg_statelen (drbg));
1014   /* we execute two rounds of V/K massaging */
1015   for (i = 2; 0 < i; i--)
1016     {
1017       /* first round uses 0x0, second 0x1 */
1018       unsigned char prefix = DRBG_PREFIX0;
1019       if (1 == i)
1020         prefix = DRBG_PREFIX1;
1021       /* 10.1.2.2 step 1 and 4 -- concatenation and HMAC for key */
1022       seed2.buf = &prefix;
1023       ret = gcry_drbg_hmac (drbg, drbg->C, drbg->C, &seed1);
1024       if (ret)
1025         return ret;
1026
1027       /* 10.1.2.2 step 2 and 5 -- HMAC for V */
1028       ret = gcry_drbg_hmac (drbg, drbg->C, drbg->V, &cipherin);
1029       if (ret)
1030         return ret;
1031
1032       /* 10.1.2.2 step 3 */
1033       if (!seed || 0 == seed->len)
1034         return ret;
1035     }
1036   return 0;
1037 }
1038
1039 /* generate function of HMAC DRBG as defined in 10.1.2.5 */
1040 static gpg_err_code_t
1041 gcry_drbg_hmac_generate (struct gcry_drbg_state *drbg,
1042                          unsigned char *buf,
1043                          unsigned int buflen, struct gcry_drbg_string *addtl)
1044 {
1045   gpg_err_code_t ret = 0;
1046   unsigned int len = 0;
1047   struct gcry_drbg_string data;
1048
1049   /* 10.1.2.5 step 2 */
1050   if (addtl && 0 < addtl->len)
1051     {
1052       addtl->next = NULL;
1053       ret = gcry_drbg_hmac_update (drbg, addtl, 1);
1054       if (ret)
1055         return ret;
1056     }
1057
1058   gcry_drbg_string_fill (&data, drbg->V, gcry_drbg_statelen (drbg));
1059   while (len < buflen)
1060     {
1061       unsigned int outlen = 0;
1062       /* 10.1.2.5 step 4.1 */
1063       ret = gcry_drbg_hmac (drbg, drbg->C, drbg->V, &data);
1064       if (ret)
1065         return ret;
1066       outlen = (gcry_drbg_blocklen (drbg) < (buflen - len)) ?
1067         gcry_drbg_blocklen (drbg) : (buflen - len);
1068
1069       /* 10.1.2.5 step 4.2 */
1070       memcpy (buf + len, drbg->V, outlen);
1071       len += outlen;
1072     }
1073
1074   /* 10.1.2.5 step 6 */
1075   if (addtl)
1076     addtl->next = NULL;
1077   ret = gcry_drbg_hmac_update (drbg, addtl, 1);
1078
1079   return ret;
1080 }
1081
1082 static struct gcry_drbg_state_ops gcry_drbg_hmac_ops = {
1083   gcry_drbg_hmac_update,
1084   gcry_drbg_hmac_generate,
1085 };
1086
1087 /******************************************************************
1088  * Hash DRBG callback functions
1089  ******************************************************************/
1090
1091 /*
1092  * scratchpad usage: as gcry_drbg_hash_update and gcry_drbg_hash_df are used
1093  * interlinked, the scratchpad is used as follows:
1094  * gcry_drbg_hash_update
1095  *      start: drbg->scratchpad
1096  *      length: gcry_drbg_statelen(drbg)
1097  * gcry_drbg_hash_df:
1098  *      start: drbg->scratchpad + gcry_drbg_statelen(drbg)
1099  *      length: gcry_drbg_blocklen(drbg)
1100  */
1101 /* Derivation Function for Hash DRBG as defined in 10.4.1 */
1102 static gpg_err_code_t
1103 gcry_drbg_hash_df (struct gcry_drbg_state *drbg,
1104                    unsigned char *outval, size_t outlen,
1105                    struct gcry_drbg_string *entropy)
1106 {
1107   gpg_err_code_t ret = 0;
1108   size_t len = 0;
1109   unsigned char input[5];
1110   unsigned char *tmp = drbg->scratchpad + gcry_drbg_statelen (drbg);
1111   struct gcry_drbg_string data1;
1112
1113   memset (tmp, 0, gcry_drbg_blocklen (drbg));
1114
1115   /* 10.4.1 step 3 */
1116   input[0] = 1;
1117   gcry_drbg_cpu_to_be32 ((outlen * 8), &input[1]);
1118
1119   /* 10.4.1 step 4.1 -- concatenation of data for input into hash */
1120   gcry_drbg_string_fill (&data1, input, 5);
1121   data1.next = entropy;
1122
1123   /* 10.4.1 step 4 */
1124   while (len < outlen)
1125     {
1126       short blocklen = 0;
1127       /* 10.4.1 step 4.1 */
1128       ret = gcry_drbg_hmac (drbg, NULL, tmp, &data1);
1129       if (ret)
1130         goto out;
1131       /* 10.4.1 step 4.2 */
1132       input[0]++;
1133       blocklen = (gcry_drbg_blocklen (drbg) < (outlen - len)) ?
1134         gcry_drbg_blocklen (drbg) : (outlen - len);
1135       memcpy (outval + len, tmp, blocklen);
1136       len += blocklen;
1137     }
1138
1139 out:
1140   memset (tmp, 0, gcry_drbg_blocklen (drbg));
1141   return ret;
1142 }
1143
1144 /* update function for Hash DRBG as defined in 10.1.1.2 / 10.1.1.3 */
1145 static gpg_err_code_t
1146 gcry_drbg_hash_update (struct gcry_drbg_state *drbg,
1147                        struct gcry_drbg_string *seed, int reseed)
1148 {
1149   gpg_err_code_t ret = 0;
1150   struct gcry_drbg_string data1, data2;
1151   unsigned char *V = drbg->scratchpad;
1152   unsigned char prefix = DRBG_PREFIX1;
1153
1154   memset (drbg->scratchpad, 0, gcry_drbg_statelen (drbg));
1155   if (!seed)
1156     return GPG_ERR_INV_ARG;
1157
1158   if (reseed)
1159     {
1160       /* 10.1.1.3 step 1: string length is concatenation of
1161        * 1 byte, V and seed (which is concatenated entropy/addtl
1162        * input)
1163        */
1164       memcpy (V, drbg->V, gcry_drbg_statelen (drbg));
1165       gcry_drbg_string_fill (&data1, &prefix, 1);
1166       gcry_drbg_string_fill (&data2, V, gcry_drbg_statelen (drbg));
1167       data1.next = &data2;
1168       data2.next = seed;
1169     }
1170   else
1171     {
1172       gcry_drbg_string_fill (&data1, seed->buf, seed->len);
1173       data1.next = seed->next;
1174     }
1175
1176   /* 10.1.1.2 / 10.1.1.3 step 2 and 3 */
1177   ret = gcry_drbg_hash_df (drbg, drbg->V, gcry_drbg_statelen (drbg), &data1);
1178   if (ret)
1179     goto out;
1180
1181   /* 10.1.1.2 / 10.1.1.3 step 4 -- concatenation  */
1182   prefix = DRBG_PREFIX0;
1183   gcry_drbg_string_fill (&data1, &prefix, 1);
1184   gcry_drbg_string_fill (&data2, drbg->V, gcry_drbg_statelen (drbg));
1185   data1.next = &data2;
1186   /* 10.1.1.2 / 10.1.1.3 step 4 -- df operation */
1187   ret = gcry_drbg_hash_df (drbg, drbg->C, gcry_drbg_statelen (drbg), &data1);
1188
1189 out:
1190   memset (drbg->scratchpad, 0, gcry_drbg_statelen (drbg));
1191   return ret;
1192 }
1193
1194 /* processing of additional information string for Hash DRBG */
1195 static gpg_err_code_t
1196 gcry_drbg_hash_process_addtl (struct gcry_drbg_state *drbg,
1197                               struct gcry_drbg_string *addtl)
1198 {
1199   gpg_err_code_t ret = 0;
1200   struct gcry_drbg_string data1, data2;
1201   struct gcry_drbg_string *data3;
1202   unsigned char prefix = DRBG_PREFIX2;
1203
1204   /* this is value w as per documentation */
1205   memset (drbg->scratchpad, 0, gcry_drbg_blocklen (drbg));
1206
1207   /* 10.1.1.4 step 2 */
1208   if (!addtl || 0 == addtl->len)
1209     return 0;
1210
1211   /* 10.1.1.4 step 2a -- concatenation */
1212   gcry_drbg_string_fill (&data1, &prefix, 1);
1213   gcry_drbg_string_fill (&data2, drbg->V, gcry_drbg_statelen (drbg));
1214   data3 = addtl;
1215   data1.next = &data2;
1216   data2.next = data3;
1217   data3->next = NULL;
1218   /* 10.1.1.4 step 2a -- cipher invocation */
1219   ret = gcry_drbg_hmac (drbg, NULL, drbg->scratchpad, &data1);
1220   if (ret)
1221     goto out;
1222
1223   /* 10.1.1.4 step 2b */
1224   gcry_drbg_add_buf (drbg->V, gcry_drbg_statelen (drbg),
1225                      drbg->scratchpad, gcry_drbg_blocklen (drbg));
1226
1227 out:
1228   memset (drbg->scratchpad, 0, gcry_drbg_blocklen (drbg));
1229   return ret;
1230 }
1231
1232 /*
1233  * Hashgen defined in 10.1.1.4
1234  */
1235 static gpg_err_code_t
1236 gcry_drbg_hash_hashgen (struct gcry_drbg_state *drbg,
1237                         unsigned char *buf, unsigned int buflen)
1238 {
1239   gpg_err_code_t ret = 0;
1240   unsigned int len = 0;
1241   unsigned char *src = drbg->scratchpad;
1242   unsigned char *dst = drbg->scratchpad + gcry_drbg_statelen (drbg);
1243   struct gcry_drbg_string data;
1244   unsigned char prefix = DRBG_PREFIX1;
1245
1246   /* use the scratchpad as a lookaside buffer */
1247   memset (src, 0, gcry_drbg_statelen (drbg));
1248   memset (dst, 0, gcry_drbg_blocklen (drbg));
1249
1250   /* 10.1.1.4 step hashgen 2 */
1251   memcpy (src, drbg->V, gcry_drbg_statelen (drbg));
1252
1253   gcry_drbg_string_fill (&data, src, gcry_drbg_statelen (drbg));
1254   while (len < buflen)
1255     {
1256       unsigned int outlen = 0;
1257       /* 10.1.1.4 step hashgen 4.1 */
1258       ret = gcry_drbg_hmac (drbg, NULL, dst, &data);
1259       if (ret)
1260         goto out;
1261       outlen = (gcry_drbg_blocklen (drbg) < (buflen - len)) ?
1262         gcry_drbg_blocklen (drbg) : (buflen - len);
1263       /* 10.1.1.4 step hashgen 4.2 */
1264       memcpy (buf + len, dst, outlen);
1265       len += outlen;
1266       /* 10.1.1.4 hashgen step 4.3 */
1267       if (len < buflen)
1268         gcry_drbg_add_buf (src, gcry_drbg_statelen (drbg), &prefix, 1);
1269     }
1270
1271 out:
1272   memset (drbg->scratchpad, 0,
1273           (gcry_drbg_statelen (drbg) + gcry_drbg_blocklen (drbg)));
1274   return ret;
1275 }
1276
1277 /* generate function for Hash DRBG as defined in  10.1.1.4 */
1278 static gpg_err_code_t
1279 gcry_drbg_hash_generate (struct gcry_drbg_state *drbg,
1280                          unsigned char *buf, unsigned int buflen,
1281                          struct gcry_drbg_string *addtl)
1282 {
1283   gpg_err_code_t ret = 0;
1284   unsigned char prefix = DRBG_PREFIX3;
1285   struct gcry_drbg_string data1, data2;
1286   union
1287   {
1288     unsigned char req[8];
1289     u64 req_int;
1290   } u;
1291
1292   /*
1293    * scratchpad usage: gcry_drbg_hash_process_addtl uses the scratchpad, but
1294    * fully completes before returning. Thus, we can reuse the scratchpad
1295    */
1296   /* 10.1.1.4 step 2 */
1297   ret = gcry_drbg_hash_process_addtl (drbg, addtl);
1298   if (ret)
1299     return ret;
1300   /* 10.1.1.4 step 3 -- invocation of the Hashgen function defined in
1301    * 10.1.1.4 */
1302   ret = gcry_drbg_hash_hashgen (drbg, buf, buflen);
1303   if (ret)
1304     return ret;
1305
1306   /* this is the value H as documented in 10.1.1.4 */
1307   memset (drbg->scratchpad, 0, gcry_drbg_blocklen (drbg));
1308   /* 10.1.1.4 step 4 */
1309   gcry_drbg_string_fill (&data1, &prefix, 1);
1310   gcry_drbg_string_fill (&data2, drbg->V, gcry_drbg_statelen (drbg));
1311   data1.next = &data2;
1312   ret = gcry_drbg_hmac (drbg, NULL, drbg->scratchpad, &data1);
1313   if (ret)
1314     goto out;
1315
1316   /* 10.1.1.4 step 5 */
1317   gcry_drbg_add_buf (drbg->V, gcry_drbg_statelen (drbg),
1318                      drbg->scratchpad, gcry_drbg_blocklen (drbg));
1319   gcry_drbg_add_buf (drbg->V, gcry_drbg_statelen (drbg), drbg->C,
1320                      gcry_drbg_statelen (drbg));
1321   u.req_int = be_bswap64 (drbg->reseed_ctr);
1322   gcry_drbg_add_buf (drbg->V, gcry_drbg_statelen (drbg), u.req,
1323                      sizeof (u.req));
1324
1325 out:
1326   memset (drbg->scratchpad, 0, gcry_drbg_blocklen (drbg));
1327   return ret;
1328 }
1329
1330 /*
1331  * scratchpad usage: as update and generate are used isolated, both
1332  * can use the scratchpad
1333  */
1334 static struct gcry_drbg_state_ops gcry_drbg_hash_ops = {
1335   gcry_drbg_hash_update,
1336   gcry_drbg_hash_generate,
1337 };
1338
1339 /******************************************************************
1340  * Functions common for DRBG implementations
1341  ******************************************************************/
1342
1343 /*
1344  * Seeding or reseeding of the DRBG
1345  *
1346  * @drbg: DRBG state struct
1347  * @pers: personalization / additional information buffer
1348  * @reseed: 0 for initial seed process, 1 for reseeding
1349  *
1350  * return:
1351  *      0 on success
1352  *      error value otherwise
1353  */
1354 static gpg_err_code_t
1355 gcry_drbg_seed (struct gcry_drbg_state *drbg, struct gcry_drbg_string *pers,
1356                 int reseed)
1357 {
1358   gpg_err_code_t ret = 0;
1359   unsigned char *entropy = NULL;
1360   size_t entropylen = 0;
1361   struct gcry_drbg_string data1;
1362
1363   /* 9.1 / 9.2 / 9.3.1 step 3 */
1364   if (pers && pers->len > (gcry_drbg_max_addtl ()))
1365     {
1366       dbg (("DRBG: personalization string too long %lu\n", pers->len));
1367       return GPG_ERR_INV_ARG;
1368     }
1369   if (drbg->test_data && drbg->test_data->testentropy)
1370     {
1371       gcry_drbg_string_fill (&data1, drbg->test_data->testentropy->buf,
1372                              drbg->test_data->testentropy->len);
1373       dbg (("DRBG: using test entropy\n"));
1374     }
1375   else
1376     {
1377       /* Gather entropy equal to the security strength of the DRBG.
1378        * With a derivation function, a nonce is required in addition
1379        * to the entropy. A nonce must be at least 1/2 of the security
1380        * strength of the DRBG in size. Thus, entropy * nonce is 3/2
1381        * of the strength. The consideration of a nonce is only
1382        * applicable during initial seeding. */
1383       entropylen = gcry_drbg_sec_strength (drbg->core->flags);
1384       if (!entropylen)
1385         return GPG_ERR_GENERAL;
1386       if (0 == reseed)
1387         /* make sure we round up strength/2 in
1388          * case it is not divisible by 2 */
1389         entropylen = ((entropylen + 1) / 2) * 3;
1390       dbg (("DRBG: (re)seeding with %lu bytes of entropy\n", entropylen));
1391       entropy = xcalloc_secure (1, entropylen);
1392       if (!entropy)
1393         return GPG_ERR_ENOMEM;
1394       ret = gcry_drbg_get_entropy (drbg, entropy, entropylen);
1395       if (ret)
1396         goto out;
1397       gcry_drbg_string_fill (&data1, entropy, entropylen);
1398     }
1399
1400   /* concatenation of entropy with personalization str / addtl input)
1401    * the variable pers is directly handed by the caller, check its
1402    * contents whether it is appropriate */
1403   if (pers && pers->buf && 0 < pers->len && NULL == pers->next)
1404     {
1405       data1.next = pers;
1406       dbg (("DRBG: using personalization string\n"));
1407     }
1408
1409   ret = drbg->d_ops->update (drbg, &data1, reseed);
1410   dbg (("DRBG: state updated with seed\n"));
1411   if (ret)
1412     goto out;
1413   drbg->seeded = 1;
1414   /* 10.1.1.2 / 10.1.1.3 step 5 */
1415   drbg->reseed_ctr = 1;
1416
1417 out:
1418   xfree (entropy);
1419   return ret;
1420 }
1421
1422 /*************************************************************************
1423  * exported interfaces
1424  *************************************************************************/
1425
1426 /*
1427  * DRBG generate function as required by SP800-90A - this function
1428  * generates random numbers
1429  *
1430  * @drbg DRBG state handle
1431  * @buf Buffer where to store the random numbers -- the buffer must already
1432  *      be pre-allocated by caller
1433  * @buflen Length of output buffer - this value defines the number of random
1434  *         bytes pulled from DRBG
1435  * @addtl Additional input that is mixed into state, may be NULL -- note
1436  *        the entropy is pulled by the DRBG internally unconditionally
1437  *        as defined in SP800-90A. The additional input is mixed into
1438  *        the state in addition to the pulled entropy.
1439  *
1440  * return: generated number of bytes
1441  */
1442 static gpg_err_code_t
1443 gcry_drbg_generate (struct gcry_drbg_state *drbg,
1444                     unsigned char *buf, unsigned int buflen,
1445                     struct gcry_drbg_string *addtl)
1446 {
1447   gpg_err_code_t ret = GPG_ERR_INV_ARG;
1448
1449   if (0 == buflen || !buf)
1450     {
1451       dbg (("DRBG: no buffer provided\n"));
1452       return ret;
1453     }
1454   if (addtl && NULL == addtl->buf && 0 < addtl->len)
1455     {
1456       dbg (("DRBG: wrong format of additional information\n"));
1457       return ret;
1458     }
1459
1460   /* 9.3.1 step 2 */
1461   if (buflen > (gcry_drbg_max_request_bytes ()))
1462     {
1463       dbg (("DRBG: requested random numbers too large %u\n", buflen));
1464       return ret;
1465     }
1466   /* 9.3.1 step 3 is implicit with the chosen DRBG */
1467   /* 9.3.1 step 4 */
1468   if (addtl && addtl->len > (gcry_drbg_max_addtl ()))
1469     {
1470       dbg (("DRBG: additional information string too long %lu\n",
1471             addtl->len));
1472       return ret;
1473     }
1474   /* 9.3.1 step 5 is implicit with the chosen DRBG */
1475   /* 9.3.1 step 6 and 9 supplemented by 9.3.2 step c -- the spec is a
1476    * bit convoluted here, we make it simpler */
1477   if ((gcry_drbg_max_requests ()) < drbg->reseed_ctr)
1478     drbg->seeded = 0;
1479
1480   if (drbg->pr || !drbg->seeded)
1481     {
1482       dbg (("DRBG: reseeding before generation (prediction resistance: %s, state %s)\n", drbg->pr ? "true" : "false", drbg->seeded ? "seeded" : "unseeded"));
1483       /* 9.3.1 steps 7.1 through 7.3 */
1484       ret = gcry_drbg_seed (drbg, addtl, 1);
1485       if (ret)
1486         return ret;
1487       /* 9.3.1 step 7.4 */
1488       addtl = NULL;
1489     }
1490
1491   if (addtl && addtl->buf)
1492     {
1493       dbg (("DRBG: using additional information string\n"));
1494     }
1495
1496   /* 9.3.1 step 8 and 10 */
1497   ret = drbg->d_ops->generate (drbg, buf, buflen, addtl);
1498
1499   /* 10.1.1.4 step 6, 10.1.2.5 step 7, 10.2.1.5.2 step 7 */
1500   drbg->reseed_ctr++;
1501   if (ret)
1502     return ret;
1503
1504   /* 11.3.3 -- re-perform self tests after some generated random
1505    * numbers, the chosen value after which self test is performed
1506    * is arbitrary, but it should be reasonable */
1507   /* Here we do not perform the self tests because of the following
1508    * reasons: it is mathematically impossible that the initial self tests
1509    * were successfully and the following are not. If the initial would
1510    * pass and the following would not, the system integrity is violated.
1511    * In this case, the entire system operation is questionable and it
1512    * is unlikely that the integrity violation only affects to the
1513    * correct operation of the DRBG.
1514    */
1515 #if 0
1516   if (drbg->reseed_ctr && !(drbg->reseed_ctr % 4096))
1517     {
1518       dbg (("DRBG: start to perform self test\n"));
1519       ret = gcry_drbg_healthcheck ();
1520       if (ret)
1521         {
1522           log_fatal (("DRBG: self test failed\n"));
1523           return ret;
1524         }
1525       else
1526         {
1527           dbg (("DRBG: self test successful\n"));
1528         }
1529     }
1530 #endif
1531
1532   return ret;
1533 }
1534
1535 /*
1536  * Wrapper around gcry_drbg_generate which can pull arbitrary long strings
1537  * from the DRBG without hitting the maximum request limitation.
1538  *
1539  * Parameters: see gcry_drbg_generate
1540  * Return codes: see gcry_drbg_generate -- if one gcry_drbg_generate request fails,
1541  *               the entire gcry_drbg_generate_long request fails
1542  */
1543 static gpg_err_code_t
1544 gcry_drbg_generate_long (struct gcry_drbg_state *drbg,
1545                          unsigned char *buf, unsigned int buflen,
1546                          struct gcry_drbg_string *addtl)
1547 {
1548   gpg_err_code_t ret = 0;
1549   unsigned int slice = 0;
1550   unsigned char *buf_p = buf;
1551   unsigned len = 0;
1552   do
1553     {
1554       unsigned int chunk = 0;
1555       slice = ((buflen - len) / gcry_drbg_max_request_bytes ());
1556       chunk = slice ? gcry_drbg_max_request_bytes () : (buflen - len);
1557       ret = gcry_drbg_generate (drbg, buf_p, chunk, addtl);
1558       if (ret)
1559         return ret;
1560       buf_p += chunk;
1561       len += chunk;
1562     }
1563   while (slice > 0 && (len < buflen));
1564   return ret;
1565 }
1566
1567 /*
1568  * DRBG uninstantiate function as required by SP800-90A - this function
1569  * frees all buffers and the DRBG handle
1570  *
1571  * @drbg DRBG state handle
1572  *
1573  * return
1574  *      0 on success
1575  */
1576 static gpg_err_code_t
1577 gcry_drbg_uninstantiate (struct gcry_drbg_state *drbg)
1578 {
1579   if (!drbg)
1580     return GPG_ERR_INV_ARG;
1581   xfree (drbg->V);
1582   drbg->V = NULL;
1583   xfree (drbg->C);
1584   drbg->C = NULL;
1585   drbg->reseed_ctr = 0;
1586   xfree (drbg->scratchpad);
1587   drbg->scratchpad = NULL;
1588   drbg->seeded = 0;
1589   drbg->pr = 0;
1590   drbg->seed_init_pid = 0;
1591   return 0;
1592 }
1593
1594 /*
1595  * DRBG instantiation function as required by SP800-90A - this function
1596  * sets up the DRBG handle, performs the initial seeding and all sanity
1597  * checks required by SP800-90A
1598  *
1599  * @drbg memory of state -- if NULL, new memory is allocated
1600  * @pers Personalization string that is mixed into state, may be NULL -- note
1601  *       the entropy is pulled by the DRBG internally unconditionally
1602  *       as defined in SP800-90A. The additional input is mixed into
1603  *       the state in addition to the pulled entropy.
1604  * @coreref reference to core
1605  * @flags Flags defining the requested DRBG type and cipher type. The flags
1606  *        are defined in drbg.h and may be XORed. Beware, if you XOR multiple
1607  *        cipher types together, the code picks the core on a first come first
1608  *        serve basis as it iterates through the available cipher cores and
1609  *        uses the one with the first match. The minimum required flags are:
1610  *              cipher type flag
1611  *
1612  * return
1613  *      0 on success
1614  *      error value otherwise
1615  */
1616 static gpg_err_code_t
1617 gcry_drbg_instantiate (struct gcry_drbg_state *drbg,
1618                        struct gcry_drbg_string *pers, int coreref, int pr)
1619 {
1620   gpg_err_code_t ret = GPG_ERR_ENOMEM;
1621   unsigned int sb_size = 0;
1622
1623   if (!drbg)
1624     return GPG_ERR_INV_ARG;
1625
1626   dbg (("DRBG: Initializing DRBG core %d with prediction resistance %s\n",
1627         coreref, pr ? "enabled" : "disabled"));
1628   drbg->core = &gcry_drbg_cores[coreref];
1629   drbg->pr = pr;
1630   drbg->seeded = 0;
1631   if (drbg->core->flags & GCRY_DRBG_HMAC)
1632     drbg->d_ops = &gcry_drbg_hmac_ops;
1633   else if (drbg->core->flags & GCRY_DRBG_HASH_MASK)
1634     drbg->d_ops = &gcry_drbg_hash_ops;
1635   else if (drbg->core->flags & GCRY_DRBG_CTR_MASK)
1636     drbg->d_ops = &gcry_drbg_ctr_ops;
1637   else
1638     return GPG_ERR_GENERAL;
1639   /* 9.1 step 1 is implicit with the selected DRBG type -- see
1640    * gcry_drbg_sec_strength() */
1641
1642   /* 9.1 step 2 is implicit as caller can select prediction resistance
1643    * and the flag is copied into drbg->flags --
1644    * all DRBG types support prediction resistance */
1645
1646   /* 9.1 step 4 is implicit in  gcry_drbg_sec_strength */
1647
1648   /* no allocation of drbg as this is done by the kernel crypto API */
1649   drbg->V = xcalloc_secure (1, gcry_drbg_statelen (drbg));
1650   if (!drbg->V)
1651     goto err;
1652   drbg->C = xcalloc_secure (1, gcry_drbg_statelen (drbg));
1653   if (!drbg->C)
1654     goto err;
1655   /* scratchpad is only generated for CTR and Hash */
1656   if (drbg->core->flags & GCRY_DRBG_HMAC)
1657     sb_size = 0;
1658   else if (drbg->core->flags & GCRY_DRBG_CTR_MASK)
1659     sb_size = gcry_drbg_statelen (drbg) + gcry_drbg_blocklen (drbg) +   /* temp */
1660       gcry_drbg_statelen (drbg) +       /* df_data */
1661       gcry_drbg_blocklen (drbg) +       /* pad */
1662       gcry_drbg_blocklen (drbg) +       /* iv */
1663       gcry_drbg_statelen (drbg) + gcry_drbg_blocklen (drbg);    /* temp */
1664   else
1665     sb_size = gcry_drbg_statelen (drbg) + gcry_drbg_blocklen (drbg);
1666
1667   if (0 < sb_size)
1668     {
1669       drbg->scratchpad = xcalloc_secure (1, sb_size);
1670       if (!drbg->scratchpad)
1671         goto err;
1672     }
1673   dbg (("DRBG: state allocated with scratchpad size %u bytes\n", sb_size));
1674
1675   /* 9.1 step 6 through 11 */
1676   ret = gcry_drbg_seed (drbg, pers, 0);
1677   if (ret)
1678     goto err;
1679
1680   dbg (("DRBG: core %d %s prediction resistance successfully initialized\n",
1681         coreref, pr ? "with" : "without"));
1682   return 0;
1683
1684 err:
1685   gcry_drbg_uninstantiate (drbg);
1686   return ret;
1687 }
1688
1689 /*
1690  * DRBG reseed function as required by SP800-90A
1691  *
1692  * @drbg DRBG state handle
1693  * @addtl Additional input that is mixed into state, may be NULL -- note
1694  *              the entropy is pulled by the DRBG internally unconditionally
1695  *              as defined in SP800-90A. The additional input is mixed into
1696  *              the state in addition to the pulled entropy.
1697  *
1698  * return
1699  *      0 on success
1700  *      error value otherwise
1701  */
1702 static gpg_err_code_t
1703 gcry_drbg_reseed (struct gcry_drbg_state *drbg,
1704                   struct gcry_drbg_string *addtl)
1705 {
1706   gpg_err_code_t ret = 0;
1707   ret = gcry_drbg_seed (drbg, addtl, 1);
1708   return ret;
1709 }
1710
1711 /******************************************************************
1712  ******************************************************************
1713  ******************************************************************
1714  * libgcrypt integration code
1715  ******************************************************************
1716  ******************************************************************
1717  ******************************************************************/
1718
1719 /***************************************************************
1720  * libgcrypt backend functions to the RNG API code
1721  ***************************************************************/
1722
1723 /* global state variable holding the current instance of the DRBG -- the
1724  * default DRBG type is defined in _gcry_gcry_drbg_init */
1725 static struct gcry_drbg_state *gcry_drbg = NULL;
1726
1727 /* This is the lock we use to serialize access to this RNG. */
1728 GPGRT_LOCK_DEFINE(drbg_lock);
1729
1730 static inline void
1731 gcry_drbg_lock (void)
1732 {
1733   gpg_err_code_t my_errno;
1734
1735   my_errno = gpgrt_lock_lock (&drbg_lock);
1736   if (my_errno)
1737     log_fatal ("failed to acquire the RNG lock: %s\n", strerror (my_errno));
1738 }
1739
1740 static inline void
1741 gcry_drbg_unlock (void)
1742 {
1743   gpg_err_code_t my_errno;
1744
1745   my_errno = gpgrt_lock_unlock (&drbg_lock);
1746   if (my_errno)
1747     log_fatal ("failed to release the RNG lock: %s\n", strerror (my_errno));
1748 }
1749
1750 /* Basic initialization is required to initialize mutexes and
1751    do a few checks on the implementation.  */
1752 static void
1753 basic_initialization (void)
1754 {
1755   static int initialized;
1756
1757   if (initialized)
1758     return;
1759   initialized = 1;
1760
1761   /* Make sure that we are still using the values we have
1762      traditionally used for the random levels.  */
1763   gcry_assert (GCRY_WEAK_RANDOM == 0
1764                && GCRY_STRONG_RANDOM == 1
1765                && GCRY_VERY_STRONG_RANDOM == 2);
1766 }
1767
1768 /****** helper functions where lock must be held by caller *****/
1769
1770 /* Check whether given flags are known to point to an applicable DRBG */
1771 static gpg_err_code_t
1772 gcry_drbg_algo_available (u32 flags, int *coreref)
1773 {
1774   int i = 0;
1775   for (i = 0; ARRAY_SIZE (gcry_drbg_cores) > i; i++)
1776     {
1777       if ((gcry_drbg_cores[i].flags & GCRY_DRBG_CIPHER_MASK) ==
1778           (flags & GCRY_DRBG_CIPHER_MASK))
1779         {
1780           *coreref = i;
1781           return 0;
1782         }
1783     }
1784   return GPG_ERR_GENERAL;
1785 }
1786
1787 static gpg_err_code_t
1788 _gcry_drbg_init_internal (u32 flags, struct gcry_drbg_string *pers)
1789 {
1790   gpg_err_code_t ret = 0;
1791   static u32 oldflags = 0;
1792   int coreref = 0;
1793   int pr = 0;
1794
1795   /* If a caller provides 0 as flags, use the flags of the previous
1796    * initialization, otherwise use the current flags and remember them
1797    * for the next invocation
1798    */
1799   if (0 == flags)
1800     flags = oldflags;
1801   else
1802     oldflags = flags;
1803
1804   ret = gcry_drbg_algo_available (flags, &coreref);
1805   if (ret)
1806     return ret;
1807
1808   if (NULL != gcry_drbg)
1809     {
1810       gcry_drbg_uninstantiate (gcry_drbg);
1811     }
1812   else
1813     {
1814       gcry_drbg = xcalloc_secure (1, sizeof (struct gcry_drbg_state));
1815       if (!gcry_drbg)
1816         return GPG_ERR_ENOMEM;
1817     }
1818   if (flags & GCRY_DRBG_PREDICTION_RESIST)
1819     pr = 1;
1820   ret = gcry_drbg_instantiate (gcry_drbg, pers, coreref, pr);
1821   if (ret)
1822     fips_signal_error ("DRBG cannot be initialized");
1823   else
1824     gcry_drbg->seed_init_pid = getpid ();
1825   return ret;
1826 }
1827
1828 /************* calls available to common RNG code **************/
1829
1830 /*
1831  * Initialize one DRBG invoked by the libgcrypt API
1832  */
1833 void
1834 _gcry_drbg_init (int full)
1835 {
1836   /* default DRBG */
1837   u32 flags = GCRY_DRBG_NOPR_HMACSHA256;
1838   basic_initialization ();
1839   if (!full)
1840       return;
1841   gcry_drbg_lock ();
1842   if (NULL == gcry_drbg)
1843     _gcry_drbg_init_internal (flags, NULL);
1844   gcry_drbg_unlock ();
1845 }
1846
1847 /*
1848  * Backend handler function for GCRYCTL_DRBG_REINIT
1849  *
1850  * Select a different DRBG type and initialize it.
1851  * Function checks whether requested DRBG type exists and returns an error in
1852  * case it does not. In case of an error, the previous instantiated DRBG is
1853  * left untouched and alive. Thus, in case of an error, a DRBG is always
1854  * available, even if it is not the chosen one.
1855  *
1856  * Re-initialization will be performed in any case regardless whether flags
1857  * or personalization string are set.
1858  *
1859  * If flags is NULL, do not change current DRBG.  If PERS is NULL and
1860  * NPERS is 0, re-initialize without personalization string.  If PERS
1861  * is not NULL NPERS must be one and PERS and the first ietm from the
1862  * bufer is take as personalization string.
1863  */
1864 gpg_err_code_t
1865 _gcry_drbg_reinit (const char *flagstr, gcry_buffer_t *pers, int npers)
1866 {
1867   gpg_err_code_t ret;
1868   unsigned int flags;
1869
1870   /* If PERS is not given we expect NPERS to be zero; if given we
1871      expect a one-item array.  */
1872   if ((!pers && npers) || (pers && npers != 1))
1873     return GPG_ERR_INV_ARG;
1874
1875   ret = parse_flag_string (flagstr, &flags);
1876   if (!ret)
1877     {
1878       dbg (("DRBG: reinitialize internal DRBG state with flags %u\n", flags));
1879       gcry_drbg_lock ();
1880       if (pers)
1881         {
1882           struct gcry_drbg_string persbuf;
1883
1884           gcry_drbg_string_fill
1885             (&persbuf, (const unsigned char *)pers[0].data + pers[0].off,
1886              pers[0].len);
1887           ret = _gcry_drbg_init_internal (flags, &persbuf);
1888         }
1889       else
1890         ret = _gcry_drbg_init_internal (flags, NULL);
1891       gcry_drbg_unlock ();
1892     }
1893   return ret;
1894 }
1895
1896 /* Try to close the FDs of the random gather module.  This is
1897  * currently only implemented for rndlinux. */
1898 void
1899 _gcry_drbg_close_fds (void)
1900 {
1901 #if USE_RNDLINUX
1902   gcry_drbg_lock ();
1903   _gcry_rndlinux_gather_random (NULL, 0, 0, 0);
1904   gcry_drbg_unlock ();
1905 #endif
1906 }
1907
1908 /* Print some statistics about the RNG.  */
1909 void
1910 _gcry_drbg_dump_stats (void)
1911 {
1912   /* Not yet implemented.  */
1913   /* Maybe dumping of reseed counter? */
1914 }
1915
1916 /* This function returns true if no real RNG is available or the
1917  * quality of the RNG has been degraded for test purposes.  */
1918 int
1919 _gcry_drbg_is_faked (void)
1920 {
1921   return 0;                     /* Faked random is not allowed.  */
1922 }
1923
1924 /* Add BUFLEN bytes from BUF to the internal random pool.  QUALITY
1925  * should be in the range of 0..100 to indicate the goodness of the
1926  * entropy added, or -1 for goodness not known. */
1927 gcry_error_t
1928 _gcry_drbg_add_bytes (const void *buf, size_t buflen, int quality)
1929 {
1930   gpg_err_code_t ret = 0;
1931   struct gcry_drbg_string seed;
1932   (void) quality;
1933   _gcry_drbg_init(1); /* Auto-initialize if needed */
1934   if (NULL == gcry_drbg)
1935     return GPG_ERR_GENERAL;
1936   gcry_drbg_string_fill (&seed, (unsigned char *) buf, buflen);
1937   gcry_drbg_lock ();
1938   ret = gcry_drbg_reseed (gcry_drbg, &seed);
1939   gcry_drbg_unlock ();
1940   return ret;
1941 }
1942
1943 /* This function is to be used for all types of random numbers, including
1944  * nonces
1945  */
1946 void
1947 _gcry_drbg_randomize (void *buffer, size_t length,
1948                       enum gcry_random_level level)
1949 {
1950   (void) level;
1951   _gcry_drbg_init(1); /* Auto-initialize if needed */
1952   gcry_drbg_lock ();
1953   if (NULL == gcry_drbg)
1954     {
1955       fips_signal_error ("DRBG is not initialized");
1956       goto bailout;
1957     }
1958
1959   /* As reseeding changes the entire state of the DRBG, including any
1960    * key, either a re-init or a reseed is sufficient for a fork */
1961   if (gcry_drbg->seed_init_pid != getpid ())
1962     {
1963       /* We are in a child of us. Perform a reseeding. */
1964       if (gcry_drbg_reseed (gcry_drbg, NULL))
1965         {
1966           fips_signal_error ("reseeding upon fork failed");
1967           log_fatal ("severe error getting random\n");
1968           goto bailout;
1969         }
1970     }
1971   /* potential integer overflow is covered by gcry_drbg_generate which
1972    * ensures that length cannot overflow an unsigned int */
1973   if (0 < length)
1974     {
1975       if (!buffer)
1976         goto bailout;
1977       if (gcry_drbg_generate_long
1978           (gcry_drbg, buffer, (unsigned int) length, NULL))
1979         log_fatal ("No random numbers generated\n");
1980     }
1981   else
1982     {
1983       struct gcry_drbg_gen *data = (struct gcry_drbg_gen *) buffer;
1984       /* catch NULL pointer */
1985       if (!data || !data->outbuf)
1986         {
1987           fips_signal_error ("No output buffer provided");
1988           goto bailout;
1989         }
1990       if (gcry_drbg_generate_long (gcry_drbg, data->outbuf, data->outlen,
1991                                    data->addtl))
1992         log_fatal ("No random numbers generated\n");
1993     }
1994 bailout:
1995   gcry_drbg_unlock ();
1996   return;
1997
1998 }
1999
2000 /***************************************************************
2001  * Self-test code
2002  ***************************************************************/
2003
2004 /*
2005  * Test vectors from
2006  * http://csrc.nist.gov/groups/STM/cavp/documents/drbg/drbgtestvectors.zip
2007  */
2008 struct gcry_drbg_test_vector gcry_drbg_test_pr[] = {
2009   {
2010    .flags = (GCRY_DRBG_PR_HASHSHA256),
2011    .entropy = (unsigned char *)
2012    "\x5d\xf2\x14\xbc\xf6\xb5\x4e\x0b\xf0\x0d\x6f\x2d"
2013    "\xe2\x01\x66\x7b\xd0\xa4\x73\xa4\x21\xdd\xb0\xc0"
2014    "\x51\x79\x09\xf4\xea\xa9\x08\xfa\xa6\x67\xe0\xe1"
2015    "\xd1\x88\xa8\xad\xee\x69\x74\xb3\x55\x06\x9b\xf6",
2016    .entropylen = 48,
2017    .entpra = (unsigned char *)
2018    "\xef\x48\x06\xa2\xc2\x45\xf1\x44\xfa\x34\x2c\xeb"
2019    "\x8d\x78\x3c\x09\x8f\x34\x72\x20\xf2\xe7\xfd\x13"
2020    "\x76\x0a\xf6\xdc\x3c\xf5\xc0\x15",
2021    .entprb = (unsigned char *)
2022    "\x4b\xbe\xe5\x24\xed\x6a\x2d\x0c\xdb\x73\x5e\x09"
2023    "\xf9\xad\x67\x7c\x51\x47\x8b\x6b\x30\x2a\xc6\xde"
2024    "\x76\xaa\x55\x04\x8b\x0a\x72\x95",
2025    .entprlen = 32,
2026    .expected = (unsigned char *)
2027    "\x3b\x14\x71\x99\xa1\xda\xa0\x42\xe6\xc8\x85\x32"
2028    "\x70\x20\x32\x53\x9a\xbe\xd1\x1e\x15\xef\xfb\x4c"
2029    "\x25\x6e\x19\x3a\xf0\xb9\xcb\xde\xf0\x3b\xc6\x18"
2030    "\x4d\x85\x5a\x9b\xf1\xe3\xc2\x23\x03\x93\x08\xdb"
2031    "\xa7\x07\x4b\x33\x78\x40\x4d\xeb\x24\xf5\x6e\x81"
2032    "\x4a\x1b\x6e\xa3\x94\x52\x43\xb0\xaf\x2e\x21\xf4"
2033    "\x42\x46\x8e\x90\xed\x34\x21\x75\xea\xda\x67\xb6"
2034    "\xe4\xf6\xff\xc6\x31\x6c\x9a\x5a\xdb\xb3\x97\x13"
2035    "\x09\xd3\x20\x98\x33\x2d\x6d\xd7\xb5\x6a\xa8\xa9"
2036    "\x9a\x5b\xd6\x87\x52\xa1\x89\x2b\x4b\x9c\x64\x60"
2037    "\x50\x47\xa3\x63\x81\x16\xaf\x19",
2038    .expectedlen = 128,
2039    .addtla = (unsigned char *)
2040    "\xbe\x13\xdb\x2a\xe9\xa8\xfe\x09\x97\xe1\xce\x5d"
2041    "\xe8\xbb\xc0\x7c\x4f\xcb\x62\x19\x3f\x0f\xd2\xad"
2042    "\xa9\xd0\x1d\x59\x02\xc4\xff\x70",
2043    .addtlb = (unsigned char *)
2044    "\x6f\x96\x13\xe2\xa7\xf5\x6c\xfe\xdf\x66\xe3\x31"
2045    "\x63\x76\xbf\x20\x27\x06\x49\xf1\xf3\x01\x77\x41"
2046    "\x9f\xeb\xe4\x38\xfe\x67\x00\xcd",
2047    .addtllen = 32,
2048    .pers = NULL,
2049    .perslen = 0,
2050    },
2051   {
2052    .flags = (GCRY_DRBG_PR_HMACSHA256),
2053    .entropy = (unsigned char *)
2054    "\x13\x54\x96\xfc\x1b\x7d\x28\xf3\x18\xc9\xa7\x89"
2055    "\xb6\xb3\xc8\x72\xac\x00\xd4\x59\x36\x25\x05\xaf"
2056    "\xa5\xdb\x96\xcb\x3c\x58\x46\x87\xa5\xaa\xbf\x20"
2057    "\x3b\xfe\x23\x0e\xd1\xc7\x41\x0f\x3f\xc9\xb3\x67",
2058    .entropylen = 48,
2059    .entpra = (unsigned char *)
2060    "\xe2\xbd\xb7\x48\x08\x06\xf3\xe1\x93\x3c\xac\x79"
2061    "\xa7\x2b\x11\xda\xe3\x2e\xe1\x91\xa5\x02\x19\x57"
2062    "\x20\x28\xad\xf2\x60\xd7\xcd\x45",
2063    .entprb = (unsigned char *)
2064    "\x8b\xd4\x69\xfc\xff\x59\x95\x95\xc6\x51\xde\x71"
2065    "\x68\x5f\xfc\xf9\x4a\xab\xec\x5a\xcb\xbe\xd3\x66"
2066    "\x1f\xfa\x74\xd3\xac\xa6\x74\x60",
2067    .entprlen = 32,
2068    .expected = (unsigned char *)
2069    "\x1f\x9e\xaf\xe4\xd2\x46\xb7\x47\x41\x4c\x65\x99"
2070    "\x01\xe9\x3b\xbb\x83\x0c\x0a\xb0\xc1\x3a\xe2\xb3"
2071    "\x31\x4e\xeb\x93\x73\xee\x0b\x26\xc2\x63\xa5\x75"
2072    "\x45\x99\xd4\x5c\x9f\xa1\xd4\x45\x87\x6b\x20\x61"
2073    "\x40\xea\x78\xa5\x32\xdf\x9e\x66\x17\xaf\xb1\x88"
2074    "\x9e\x2e\x23\xdd\xc1\xda\x13\x97\x88\xa5\xb6\x5e"
2075    "\x90\x14\x4e\xef\x13\xab\x5c\xd9\x2c\x97\x9e\x7c"
2076    "\xd7\xf8\xce\xea\x81\xf5\xcd\x71\x15\x49\x44\xce"
2077    "\x83\xb6\x05\xfb\x7d\x30\xb5\x57\x2c\x31\x4f\xfc"
2078    "\xfe\x80\xb6\xc0\x13\x0c\x5b\x9b\x2e\x8f\x3d\xfc"
2079    "\xc2\xa3\x0c\x11\x1b\x80\x5f\xf3",
2080    .expectedlen = 128,
2081    .addtla = NULL,
2082    .addtlb = NULL,
2083    .addtllen = 0,
2084    .pers = (unsigned char *)
2085    "\x64\xb6\xfc\x60\xbc\x61\x76\x23\x6d\x3f\x4a\x0f"
2086    "\xe1\xb4\xd5\x20\x9e\x70\xdd\x03\x53\x6d\xbf\xce"
2087    "\xcd\x56\x80\xbc\xb8\x15\xc8\xaa",
2088    .perslen = 32,
2089    },
2090   {
2091    .flags = (GCRY_DRBG_PR_CTRAES128),
2092    .entropy = (unsigned char *)
2093    "\x92\x89\x8f\x31\xfa\x1c\xff\x6d\x18\x2f\x26\x06"
2094    "\x43\xdf\xf8\x18\xc2\xa4\xd9\x72\xc3\xb9\xb6\x97",
2095    .entropylen = 24,
2096    .entpra = (unsigned char *)
2097    "\x20\x72\x8a\x06\xf8\x6f\x8d\xd4\x41\xe2\x72\xb7"
2098    "\xc4\x2c\xe8\x10",
2099    .entprb = (unsigned char *)
2100    "\x3d\xb0\xf0\x94\xf3\x05\x50\x33\x17\x86\x3e\x22"
2101    "\x08\xf7\xa5\x01",
2102    .entprlen = 16,
2103    .expected = (unsigned char *)
2104    "\x5a\x35\x39\x87\x0f\x4d\x22\xa4\x09\x24\xee\x71"
2105    "\xc9\x6f\xac\x72\x0a\xd6\xf0\x88\x82\xd0\x83\x28"
2106    "\x73\xec\x3f\x93\xd8\xab\x45\x23\xf0\x7e\xac\x45"
2107    "\x14\x5e\x93\x9f\xb1\xd6\x76\x43\x3d\xb6\xe8\x08"
2108    "\x88\xf6\xda\x89\x08\x77\x42\xfe\x1a\xf4\x3f\xc4"
2109    "\x23\xc5\x1f\x68",
2110    .expectedlen = 64,
2111    .addtla = (unsigned char *)
2112    "\x1a\x40\xfa\xe3\xcc\x6c\x7c\xa0\xf8\xda\xba\x59"
2113    "\x23\x6d\xad\x1d",
2114    .addtlb = (unsigned char *)
2115    "\x9f\x72\x76\x6c\xc7\x46\xe5\xed\x2e\x53\x20\x12"
2116    "\xbc\x59\x31\x8c",
2117    .addtllen = 16,
2118    .pers = (unsigned char *)
2119    "\xea\x65\xee\x60\x26\x4e\x7e\xb6\x0e\x82\x68\xc4"
2120    "\x37\x3c\x5c\x0b",
2121    .perslen = 16,
2122    },
2123 };
2124
2125 struct gcry_drbg_test_vector gcry_drbg_test_nopr[] = {
2126   {
2127    .flags = GCRY_DRBG_NOPR_HASHSHA256,
2128    .entropy = (unsigned char *)
2129    "\x73\xd3\xfb\xa3\x94\x5f\x2b\x5f\xb9\x8f\xf6\x9c"
2130    "\x8a\x93\x17\xae\x19\xc3\x4c\xc3\xd6\xca\xa3\x2d"
2131    "\x16\xfc\x42\xd2\x2d\xd5\x6f\x56\xcc\x1d\x30\xff"
2132    "\x9e\x06\x3e\x09\xce\x58\xe6\x9a\x35\xb3\xa6\x56",
2133    .entropylen = 48,
2134    .expected = (unsigned char *)
2135    "\x71\x7b\x93\x46\x1a\x40\xaa\x35\xa4\xaa\xc5\xe7"
2136    "\x6d\x5b\x5b\x8a\xa0\xdf\x39\x7d\xae\x71\x58\x5b"
2137    "\x3c\x7c\xb4\xf0\x89\xfa\x4a\x8c\xa9\x5c\x54\xc0"
2138    "\x40\xdf\xbc\xce\x26\x81\x34\xf8\xba\x7d\x1c\xe8"
2139    "\xad\x21\xe0\x74\xcf\x48\x84\x30\x1f\xa1\xd5\x4f"
2140    "\x81\x42\x2f\xf4\xdb\x0b\x23\xf8\x73\x27\xb8\x1d"
2141    "\x42\xf8\x44\x58\xd8\x5b\x29\x27\x0a\xf8\x69\x59"
2142    "\xb5\x78\x44\xeb\x9e\xe0\x68\x6f\x42\x9a\xb0\x5b"
2143    "\xe0\x4e\xcb\x6a\xaa\xe2\xd2\xd5\x33\x25\x3e\xe0"
2144    "\x6c\xc7\x6a\x07\xa5\x03\x83\x9f\xe2\x8b\xd1\x1c"
2145    "\x70\xa8\x07\x59\x97\xeb\xf6\xbe",
2146    .expectedlen = 128,
2147    .addtla = (unsigned char *)
2148    "\xf4\xd5\x98\x3d\xa8\xfc\xfa\x37\xb7\x54\x67\x73"
2149    "\xc7\xc3\xdd\x47\x34\x71\x02\x5d\xc1\xa0\xd3\x10"
2150    "\xc1\x8b\xbd\xf5\x66\x34\x6f\xdd",
2151    .addtlb = (unsigned char *)
2152    "\xf7\x9e\x6a\x56\x0e\x73\xe9\xd9\x7a\xd1\x69\xe0"
2153    "\x6f\x8c\x55\x1c\x44\xd1\xce\x6f\x28\xcc\xa4\x4d"
2154    "\xa8\xc0\x85\xd1\x5a\x0c\x59\x40",
2155    .addtllen = 32,
2156    .pers = NULL,
2157    .perslen = 0,
2158    },
2159   {
2160    .flags = GCRY_DRBG_NOPR_HMACSHA256,
2161    .entropy = (unsigned char *)
2162    "\x8d\xf0\x13\xb4\xd1\x03\x52\x30\x73\x91\x7d\xdf"
2163    "\x6a\x86\x97\x93\x05\x9e\x99\x43\xfc\x86\x54\x54"
2164    "\x9e\x7a\xb2\x2f\x7c\x29\xf1\x22\xda\x26\x25\xaf"
2165    "\x2d\xdd\x4a\xbc\xce\x3c\xf4\xfa\x46\x59\xd8\x4e",
2166    .entropylen = 48,
2167    .expected = (unsigned char *)
2168    "\xb9\x1c\xba\x4c\xc8\x4f\xa2\x5d\xf8\x61\x0b\x81"
2169    "\xb6\x41\x40\x27\x68\xa2\x09\x72\x34\x93\x2e\x37"
2170    "\xd5\x90\xb1\x15\x4c\xbd\x23\xf9\x74\x52\xe3\x10"
2171    "\xe2\x91\xc4\x51\x46\x14\x7f\x0d\xa2\xd8\x17\x61"
2172    "\xfe\x90\xfb\xa6\x4f\x94\x41\x9c\x0f\x66\x2b\x28"
2173    "\xc1\xed\x94\xda\x48\x7b\xb7\xe7\x3e\xec\x79\x8f"
2174    "\xbc\xf9\x81\xb7\x91\xd1\xbe\x4f\x17\x7a\x89\x07"
2175    "\xaa\x3c\x40\x16\x43\xa5\xb6\x2b\x87\xb8\x9d\x66"
2176    "\xb3\xa6\x0e\x40\xd4\xa8\xe4\xe9\xd8\x2a\xf6\xd2"
2177    "\x70\x0e\x6f\x53\x5c\xdb\x51\xf7\x5c\x32\x17\x29"
2178    "\x10\x37\x41\x03\x0c\xcc\x3a\x56",
2179    .expectedlen = 128,
2180    .addtla = NULL,
2181    .addtlb = NULL,
2182    .addtllen = 0,
2183    .pers = (unsigned char *)
2184    "\xb5\x71\xe6\x6d\x7c\x33\x8b\xc0\x7b\x76\xad\x37"
2185    "\x57\xbb\x2f\x94\x52\xbf\x7e\x07\x43\x7a\xe8\x58"
2186    "\x1c\xe7\xbc\x7c\x3a\xc6\x51\xa9",
2187    .perslen = 32,
2188    },
2189   {
2190    .flags = GCRY_DRBG_NOPR_CTRAES128,
2191    .entropy = (unsigned char *)
2192    "\xc0\x70\x1f\x92\x50\x75\x8f\xcd\xf2\xbe\x73\x98"
2193    "\x80\xdb\x66\xeb\x14\x68\xb4\xa5\x87\x9c\x2d\xa6",
2194    .entropylen = 24,
2195    .expected = (unsigned char *)
2196    "\x97\xc0\xc0\xe5\xa0\xcc\xf2\x4f\x33\x63\x48\x8a"
2197    "\xdb\x13\x0a\x35\x89\xbf\x80\x65\x62\xee\x13\x95"
2198    "\x7c\x33\xd3\x7d\xf4\x07\x77\x7a\x2b\x65\x0b\x5f"
2199    "\x45\x5c\x13\xf1\x90\x77\x7f\xc5\x04\x3f\xcc\x1a"
2200    "\x38\xf8\xcd\x1b\xbb\xd5\x57\xd1\x4a\x4c\x2e\x8a"
2201    "\x2b\x49\x1e\x5c",
2202    .expectedlen = 64,
2203    .addtla = (unsigned char *)
2204    "\xf9\x01\xf8\x16\x7a\x1d\xff\xde\x8e\x3c\x83\xe2"
2205    "\x44\x85\xe7\xfe",
2206    .addtlb = (unsigned char *)
2207    "\x17\x1c\x09\x38\xc2\x38\x9f\x97\x87\x60\x55\xb4"
2208    "\x82\x16\x62\x7f",
2209    .addtllen = 16,
2210    .pers = (unsigned char *)
2211    "\x80\x08\xae\xe8\xe9\x69\x40\xc5\x08\x73\xc7\x9f"
2212    "\x8e\xcf\xe0\x02",
2213    .perslen = 16,
2214    },
2215   {
2216    .flags = GCRY_DRBG_NOPR_HASHSHA1,
2217    .entropy = (unsigned char *)
2218    "\x16\x10\xb8\x28\xcc\xd2\x7d\xe0\x8c\xee\xa0\x32"
2219    "\xa2\x0e\x92\x08\x49\x2c\xf1\x70\x92\x42\xf6\xb5",
2220    .entropylen = 24,
2221    .expected = (unsigned char *)
2222    "\x56\xf3\x3d\x4f\xdb\xb9\xa5\xb6\x4d\x26\x23\x44"
2223    "\x97\xe9\xdc\xb8\x77\x98\xc6\x8d\x08\xf7\xc4\x11"
2224    "\x99\xd4\xbd\xdf\x97\xeb\xbf\x6c\xb5\x55\x0e\x5d"
2225    "\x14\x9f\xf4\xd5\xbd\x0f\x05\xf2\x5a\x69\x88\xc1"
2226    "\x74\x36\x39\x62\x27\x18\x4a\xf8\x4a\x56\x43\x35"
2227    "\x65\x8e\x2f\x85\x72\xbe\xa3\x33\xee\xe2\xab\xff"
2228    "\x22\xff\xa6\xde\x3e\x22\xac\xa2",
2229    .expectedlen = 80,
2230    .addtla = NULL,
2231    .addtlb = NULL,
2232    .addtllen = 0,
2233    .pers = NULL,
2234    .perslen = 0,
2235    .entropyreseed = (unsigned char *)
2236    "\x72\xd2\x8c\x90\x8e\xda\xf9\xa4\xd1\xe5\x26\xd8"
2237    "\xf2\xde\xd5\x44",
2238    .entropyreseed_len = 16,
2239    .addtl_reseed = NULL,
2240    .addtl_reseed_len = 0,
2241    },
2242   {
2243    .flags = GCRY_DRBG_NOPR_HASHSHA1,
2244    .entropy = (unsigned char *)
2245    "\xd9\xba\xb5\xce\xdc\xa9\x6f\x61\x78\xd6\x45\x09"
2246    "\xa0\xdf\xdc\x5e\xda\xd8\x98\x94\x14\x45\x0e\x01",
2247    .entropylen = 24,
2248    .expected = (unsigned char *)
2249    "\xc4\x8b\x89\xf9\xda\x3f\x74\x82\x45\x55\x5d\x5d"
2250    "\x03\x3b\x69\x3d\xd7\x1a\x4d\xf5\x69\x02\x05\xce"
2251    "\xfc\xd7\x20\x11\x3c\xc2\x4e\x09\x89\x36\xff\x5e"
2252    "\x77\xb5\x41\x53\x58\x70\xb3\x39\x46\x8c\xdd\x8d"
2253    "\x6f\xaf\x8c\x56\x16\x3a\x70\x0a\x75\xb2\x3e\x59"
2254    "\x9b\x5a\xec\xf1\x6f\x3b\xaf\x6d\x5f\x24\x19\x97"
2255    "\x1f\x24\xf4\x46\x72\x0f\xea\xbe",
2256    .expectedlen = 80,
2257    .addtla = (unsigned char *)
2258    "\x04\xfa\x28\x95\xaa\x5a\x6f\x8c\x57\x43\x34\x3b"
2259    "\x80\x5e\x5e\xa4",
2260    .addtlb = (unsigned char *)
2261    "\xdf\x5d\xc4\x59\xdf\xf0\x2a\xa2\xf0\x52\xd7\x21"
2262    "\xec\x60\x72\x30",
2263    .addtllen = 16,
2264    .pers = NULL,
2265    .perslen = 0,
2266    .entropyreseed = (unsigned char *)
2267    "\xc6\xba\xd0\x74\xc5\x90\x67\x86\xf5\xe1\xf3\x20"
2268    "\x99\xf5\xb4\x91",
2269    .entropyreseed_len = 16,
2270    .addtl_reseed = (unsigned char *)
2271    "\x3e\x6b\xf4\x6f\x4d\xaa\x38\x25\xd7\x19\x4e\x69"
2272    "\x4e\x77\x52\xf7",
2273    .addtl_reseed_len = 16,
2274    },
2275 };
2276
2277
2278 /*
2279  * Tests implement the CAVS test approach as documented in
2280  * http://csrc.nist.gov/groups/STM/cavp/documents/drbg/DRBGVS.pdf
2281  */
2282
2283 /*
2284  * CAVS test
2285  *
2286  * This function is not static as it is needed for as a private API
2287  * call for the CAVS test tool.
2288  */
2289 gpg_err_code_t
2290 gcry_drbg_cavs_test (struct gcry_drbg_test_vector *test, unsigned char *buf)
2291 {
2292   gpg_err_code_t ret = 0;
2293   struct gcry_drbg_state *drbg = NULL;
2294   struct gcry_drbg_test_data test_data;
2295   struct gcry_drbg_string addtl, pers, testentropy;
2296   int coreref = 0;
2297   int pr = 0;
2298
2299   ret = gcry_drbg_algo_available (test->flags, &coreref);
2300   if (ret)
2301     goto outbuf;
2302
2303   drbg = xcalloc_secure (1, sizeof (struct gcry_drbg_state));
2304   if (!drbg)
2305     {
2306       ret = GPG_ERR_ENOMEM;
2307       goto outbuf;
2308     }
2309
2310   if (test->flags & GCRY_DRBG_PREDICTION_RESIST)
2311     pr = 1;
2312
2313   test_data.testentropy = &testentropy;
2314   gcry_drbg_string_fill (&testentropy, test->entropy, test->entropylen);
2315   drbg->test_data = &test_data;
2316   gcry_drbg_string_fill (&pers, test->pers, test->perslen);
2317   ret = gcry_drbg_instantiate (drbg, &pers, coreref, pr);
2318   if (ret)
2319     goto outbuf;
2320
2321   if (test->entropyreseed)
2322     {
2323       gcry_drbg_string_fill (&testentropy, test->entropyreseed,
2324                              test->entropyreseed_len);
2325       gcry_drbg_string_fill (&addtl, test->addtl_reseed,
2326                              test->addtl_reseed_len);
2327       if (gcry_drbg_reseed (drbg, &addtl))
2328         goto outbuf;
2329     }
2330
2331   gcry_drbg_string_fill (&addtl, test->addtla, test->addtllen);
2332   if (test->entpra)
2333     {
2334       gcry_drbg_string_fill (&testentropy, test->entpra, test->entprlen);
2335       drbg->test_data = &test_data;
2336     }
2337   gcry_drbg_generate_long (drbg, buf, test->expectedlen, &addtl);
2338
2339   gcry_drbg_string_fill (&addtl, test->addtlb, test->addtllen);
2340   if (test->entprb)
2341     {
2342       gcry_drbg_string_fill (&testentropy, test->entprb, test->entprlen);
2343       drbg->test_data = &test_data;
2344     }
2345   gcry_drbg_generate_long (drbg, buf, test->expectedlen, &addtl);
2346   gcry_drbg_uninstantiate (drbg);
2347
2348 outbuf:
2349   xfree (drbg);
2350   return ret;
2351 }
2352
2353 /*
2354  * Invoke the CAVS test and perform the final check whether the
2355  * calculated random value matches the expected one.
2356  *
2357  * This function is not static as it is needed for as a private API
2358  * call for the CAVS test tool.
2359  */
2360 gpg_err_code_t
2361 gcry_drbg_healthcheck_one (struct gcry_drbg_test_vector * test)
2362 {
2363   gpg_err_code_t ret = GPG_ERR_ENOMEM;
2364   unsigned char *buf = xcalloc_secure (1, test->expectedlen);
2365   if (!buf)
2366     return GPG_ERR_ENOMEM;
2367
2368   ret = gcry_drbg_cavs_test (test, buf);
2369   ret = memcmp (test->expected, buf, test->expectedlen);
2370
2371   xfree (buf);
2372   return ret;
2373 }
2374
2375 /*
2376  * Tests as defined in 11.3.2 in addition to the cipher tests: testing
2377  * of the error handling.
2378  *
2379  * Note, testing the reseed counter is not done as an automatic reseeding
2380  * is performed in gcry_drbg_generate when the reseed counter is too large.
2381  */
2382 static gpg_err_code_t
2383 gcry_drbg_healthcheck_sanity (struct gcry_drbg_test_vector *test)
2384 {
2385   unsigned int len = 0;
2386   struct gcry_drbg_state *drbg = NULL;
2387   gpg_err_code_t ret = GPG_ERR_GENERAL;
2388   gpg_err_code_t tmpret = GPG_ERR_GENERAL;
2389   struct gcry_drbg_test_data test_data;
2390   struct gcry_drbg_string addtl, testentropy;
2391   int coreref = 0;
2392   unsigned char *buf = NULL;
2393   size_t max_addtllen, max_request_bytes;
2394
2395   /* only perform test in FIPS mode */
2396   if (0 == fips_mode ())
2397     return 0;
2398
2399   buf = xcalloc_secure (1, test->expectedlen);
2400   if (!buf)
2401     return GPG_ERR_ENOMEM;
2402   tmpret = gcry_drbg_algo_available (test->flags, &coreref);
2403   if (tmpret)
2404     goto outbuf;
2405   drbg = xcalloc_secure (1, sizeof (struct gcry_drbg_state));
2406   if (!drbg)
2407     goto outbuf;
2408
2409   /* if the following tests fail, it is likely that there is a buffer
2410    * overflow and we get a SIGSEV */
2411   ret = gcry_drbg_instantiate (drbg, NULL, coreref, 1);
2412   if (ret)
2413     goto outbuf;
2414   max_addtllen = gcry_drbg_max_addtl ();
2415   max_request_bytes = gcry_drbg_max_request_bytes ();
2416   /* overflow addtllen with additonal info string */
2417   gcry_drbg_string_fill (&addtl, test->addtla, (max_addtllen + 1));
2418   len = gcry_drbg_generate (drbg, buf, test->expectedlen, &addtl);
2419   if (len)
2420     goto outdrbg;
2421
2422   /* overflow max_bits */
2423   len = gcry_drbg_generate (drbg, buf, (max_request_bytes + 1), NULL);
2424   if (len)
2425     goto outdrbg;
2426   gcry_drbg_uninstantiate (drbg);
2427
2428   /* test failing entropy source as defined in 11.3.2 */
2429   test_data.testentropy = NULL;
2430   test_data.fail_seed_source = 1;
2431   drbg->test_data = &test_data;
2432   tmpret = gcry_drbg_instantiate (drbg, NULL, coreref, 0);
2433   if (!tmpret)
2434     goto outdrbg;
2435   test_data.fail_seed_source = 0;
2436
2437   test_data.testentropy = &testentropy;
2438   gcry_drbg_string_fill (&testentropy, test->entropy, test->entropylen);
2439   /* overflow max addtllen with personalization string */
2440   tmpret = gcry_drbg_instantiate (drbg, &addtl, coreref, 0);
2441   if (!tmpret)
2442     goto outdrbg;
2443
2444   dbg (("DRBG: Sanity tests for failure code paths successfully completed\n"));
2445   ret = 0;
2446
2447 outdrbg:
2448   gcry_drbg_uninstantiate (drbg);
2449 outbuf:
2450   xfree (buf);
2451   xfree (drbg);
2452   return ret;
2453 }
2454
2455 /*
2456  * DRBG Healthcheck function as required in SP800-90A
2457  *
2458  * return:
2459  *      0 on success (all tests pass)
2460  *      >0 on error (return code indicate the number of failures)
2461  */
2462 static int
2463 gcry_drbg_healthcheck (void)
2464 {
2465   int ret = 0;
2466   ret += gcry_drbg_healthcheck_one (&gcry_drbg_test_nopr[0]);
2467   ret += gcry_drbg_healthcheck_one (&gcry_drbg_test_nopr[1]);
2468   ret += gcry_drbg_healthcheck_one (&gcry_drbg_test_nopr[2]);
2469   ret += gcry_drbg_healthcheck_one (&gcry_drbg_test_nopr[3]);
2470   ret += gcry_drbg_healthcheck_one (&gcry_drbg_test_nopr[4]);
2471   ret += gcry_drbg_healthcheck_one (&gcry_drbg_test_pr[0]);
2472   ret += gcry_drbg_healthcheck_one (&gcry_drbg_test_pr[1]);
2473   ret += gcry_drbg_healthcheck_one (&gcry_drbg_test_pr[2]);
2474   ret += gcry_drbg_healthcheck_sanity (&gcry_drbg_test_nopr[0]);
2475   return ret;
2476 }
2477
2478 /* Run the self-tests.  */
2479 gcry_error_t
2480 _gcry_drbg_selftest (selftest_report_func_t report)
2481 {
2482   gcry_err_code_t ec;
2483   const char *errtxt = NULL;
2484   gcry_drbg_lock ();
2485   if (0 != gcry_drbg_healthcheck ())
2486     errtxt = "RNG output does not match known value";
2487   gcry_drbg_unlock ();
2488   if (report && errtxt)
2489     report ("random", 0, "KAT", errtxt);
2490   ec = errtxt ? GPG_ERR_SELFTEST_FAILED : 0;
2491   return gpg_error (ec);
2492 }
2493
2494 /***************************************************************
2495  * Cipher invocations requested by DRBG
2496  ***************************************************************/
2497
2498 static gpg_err_code_t
2499 gcry_drbg_hmac (struct gcry_drbg_state *drbg, const unsigned char *key,
2500                 unsigned char *outval, const struct gcry_drbg_string *buf)
2501 {
2502   gpg_error_t err;
2503   gcry_md_hd_t hd;
2504
2505   if (key)
2506     {
2507       err =
2508         _gcry_md_open (&hd, drbg->core->backend_cipher, GCRY_MD_FLAG_HMAC);
2509       if (err)
2510         return err;
2511       err = _gcry_md_setkey (hd, key, gcry_drbg_statelen (drbg));
2512       if (err)
2513         return err;
2514     }
2515   else
2516     {
2517       err = _gcry_md_open (&hd, drbg->core->backend_cipher, 0);
2518       if (err)
2519         return err;
2520     }
2521   for (; NULL != buf; buf = buf->next)
2522     _gcry_md_write (hd, buf->buf, buf->len);
2523   _gcry_md_final (hd);
2524   memcpy (outval, _gcry_md_read (hd, drbg->core->backend_cipher),
2525           gcry_drbg_blocklen (drbg));
2526   _gcry_md_close (hd);
2527   return 0;
2528 }
2529
2530 static gpg_err_code_t
2531 gcry_drbg_sym (struct gcry_drbg_state *drbg, const unsigned char *key,
2532                unsigned char *outval, const struct gcry_drbg_string *buf)
2533 {
2534   gpg_error_t err;
2535   gcry_cipher_hd_t hd;
2536
2537   err =
2538     _gcry_cipher_open (&hd, drbg->core->backend_cipher, GCRY_CIPHER_MODE_ECB,
2539                        0);
2540   if (err)
2541     return err;
2542   if (gcry_drbg_blocklen (drbg) !=
2543       _gcry_cipher_get_algo_blklen (drbg->core->backend_cipher))
2544     return -GPG_ERR_NO_ERROR;
2545   if (gcry_drbg_blocklen (drbg) < buf->len)
2546     return -GPG_ERR_NO_ERROR;
2547   err = _gcry_cipher_setkey (hd, key, gcry_drbg_keylen (drbg));
2548   if (err)
2549     return err;
2550   /* in is only component */
2551   _gcry_cipher_encrypt (hd, outval, gcry_drbg_blocklen (drbg), buf->buf,
2552                         buf->len);
2553   _gcry_cipher_close (hd);
2554   return 0;
2555 }