contrib/unbound/util/random.c

   1 /*
   2  * util/random.c - thread safe random generator, which is reasonably secure.
   3  *
   4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
   5  *
   6  * This software is open source.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  15  * Redistributions in binary form must reproduce the above copyright notice,
  16  * this list of conditions and the following disclaimer in the documentation
  17  * and/or other materials provided with the distribution.
  18  *
  19  * Neither the name of the NLNET LABS nor the names of its contributors may
  20  * be used to endorse or promote products derived from this software without
  21  * specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  29  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 /**
  37  * \file
  38  * Thread safe random functions. Similar to arc4random() with an explicit
  39  * initialisation routine.
  40  *
  41  * The code in this file is based on arc4random from
  42  * openssh-4.0p1/openbsd-compat/bsd-arc4random.c
  43  * That code is also BSD licensed. Here is their statement:
  44  *
  45  * Copyright (c) 1996, David Mazieres <dm@uun.org>
  46  * Copyright (c) 2008, Damien Miller <djm@openbsd.org>
  47  *
  48  * Permission to use, copy, modify, and distribute this software for any
  49  * purpose with or without fee is hereby granted, provided that the above
  50  * copyright notice and this permission notice appear in all copies.
  51  *
  52  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  53  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  54  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  55  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  56  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  57  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  58  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  59  */
  60 #include "config.h"
  61 #include "util/random.h"
  62 #include "util/log.h"
  63 #include <time.h>
  64
  65 #ifdef HAVE_NSS
  66 /* nspr4 */
  67 #include "prerror.h"
  68 /* nss3 */
  69 #include "secport.h"
  70 #include "pk11pub.h"
  71 #elif defined(HAVE_NETTLE)
  72 #include "yarrow.h"
  73 #endif
  74
  75 /**
  76  * Max random value.  Similar to RAND_MAX, but more portable
  77  * (mingw uses only 15 bits random).
  78  */
  79 #define MAX_VALUE 0x7fffffff
  80
  81 #if defined(HAVE_SSL) || defined(HAVE_LIBBSD)
  82 struct ub_randstate*
  83 ub_initstate(struct ub_randstate* ATTR_UNUSED(from))
  84 {
  85         struct ub_randstate* s = (struct ub_randstate*)malloc(1);
  86         if(!s) {
  87                 log_err("malloc failure in random init");
  88                 return NULL;
  89         }
  90         return s;
  91 }
  92
  93 long int
  94 ub_random(struct ub_randstate* ATTR_UNUSED(s))
  95 {
  96         /* This relies on MAX_VALUE being 0x7fffffff. */
  97         return (long)arc4random() & MAX_VALUE;
  98 }
  99
 100 long int
 101 ub_random_max(struct ub_randstate* state, long int x)
 102 {
 103         (void)state;
 104         /* on OpenBSD, this does not need _seed(), or _stir() calls */
 105         return (long)arc4random_uniform((uint32_t)x);
 106 }
 107
 108 #elif defined(HAVE_NSS)
 109
 110 /* not much to remember for NSS since we use its pk11_random, placeholder */
 111 struct ub_randstate {
 112         int ready;
 113 };
 114
 115 struct ub_randstate* ub_initstate(struct ub_randstate* ATTR_UNUSED(from))
 116 {
 117         struct ub_randstate* s = (struct ub_randstate*)calloc(1, sizeof(*s));
 118         if(!s) {
 119                 log_err("malloc failure in random init");
 120                 return NULL;
 121         }
 122         return s;
 123 }
 124
 125 long int ub_random(struct ub_randstate* ATTR_UNUSED(state))
 126 {
 127         long int x;
 128         /* random 31 bit value. */
 129         SECStatus s = PK11_GenerateRandom((unsigned char*)&x, (int)sizeof(x));
 130         if(s != SECSuccess) {
 131                 /* unbound needs secure randomness for randomized
 132                  * ID bits and port numbers in packets to upstream servers */
 133                 fatal_exit("PK11_GenerateRandom error: %s",
 134                         PORT_ErrorToString(PORT_GetError()));
 135         }
 136         return x & MAX_VALUE;
 137 }
 138
 139 #elif defined(HAVE_NETTLE)
 140
 141 /**
 142  * libnettle implements a Yarrow-256 generator (SHA256 + AES),
 143  * and we have to ensure it is seeded before use.
 144  */
 145 struct ub_randstate {
 146         struct yarrow256_ctx ctx;
 147         int seeded;
 148 };
 149
 150 struct ub_randstate* ub_initstate(struct ub_randstate* ATTR_UNUSED(from))
 151 {
 152         struct ub_randstate* s = (struct ub_randstate*)calloc(1, sizeof(*s));
 153         uint8_t buf[YARROW256_SEED_FILE_SIZE];
 154         if(!s) {
 155                 log_err("malloc failure in random init");
 156                 return NULL;
 157         }
 158         /* Setup Yarrow context */
 159         yarrow256_init(&s->ctx, 0, NULL);
 160
 161         if(getentropy(buf, sizeof(buf)) != -1) {
 162                 /* got entropy */
 163                 yarrow256_seed(&s->ctx, YARROW256_SEED_FILE_SIZE, buf);
 164                 s->seeded = yarrow256_is_seeded(&s->ctx);
 165         } else {
 166                 log_err("nettle random(yarrow) cannot initialize, "
 167                         "getentropy failed: %s", strerror(errno));
 168                 free(s);
 169                 return NULL;
 170         }
 171
 172         return s;
 173 }
 174
 175 long int ub_random(struct ub_randstate* s)
 176 {
 177         /* random 31 bit value. */
 178         long int x = 0;
 179         if (!s || !s->seeded) {
 180                 log_err("Couldn't generate randomness, Yarrow-256 generator not yet seeded");
 181         } else {
 182                 yarrow256_random(&s->ctx, sizeof(x), (uint8_t *)&x);
 183         }
 184         return x & MAX_VALUE;
 185 }
 186 #endif /* HAVE_SSL or HAVE_LIBBSD or HAVE_NSS or HAVE_NETTLE */
 187
 188
 189 #if defined(HAVE_NSS) || defined(HAVE_NETTLE) && !defined(HAVE_LIBBSD)
 190 long int
 191 ub_random_max(struct ub_randstate* state, long int x)
 192 {
 193         /* make sure we fetch in a range that is divisible by x. ignore
 194          * values from d .. MAX_VALUE, instead draw a new number */
 195         long int d = MAX_VALUE - (MAX_VALUE % x); /* d is divisible by x */
 196         long int v = ub_random(state);
 197         while(d <= v)
 198                 v = ub_random(state);
 199         return (v % x);
 200 }
 201 #endif /* HAVE_NSS or HAVE_NETTLE and !HAVE_LIBBSD */
 202
 203 void
 204 ub_randfree(struct ub_randstate* s)
 205 {
 206         free(s);
 207         /* user app must do RAND_cleanup(); */
 208 }