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