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 #endif
  72
  73 /**
  74  * Max random value.  Similar to RAND_MAX, but more portable
  75  * (mingw uses only 15 bits random).
  76  */
  77 #define MAX_VALUE 0x7fffffff
  78
  79 #ifndef HAVE_NSS
  80 void
  81 ub_systemseed(unsigned int ATTR_UNUSED(seed))
  82 {
  83         /* arc4random_uniform does not need seeds, it gets kernel entropy */
  84 }
  85
  86 struct ub_randstate*
  87 ub_initstate(unsigned int ATTR_UNUSED(seed),
  88         struct ub_randstate* ATTR_UNUSED(from))
  89 {
  90         struct ub_randstate* s = (struct ub_randstate*)malloc(1);
  91         if(!s) {
  92                 log_err("malloc failure in random init");
  93                 return NULL;
  94         }
  95         return s;
  96 }
  97
  98 long int
  99 ub_random(struct ub_randstate* ATTR_UNUSED(s))
 100 {
 101         /* This relies on MAX_VALUE being 0x7fffffff. */
 102         return (long)arc4random() & MAX_VALUE;
 103 }
 104
 105 long int
 106 ub_random_max(struct ub_randstate* state, long int x)
 107 {
 108         (void)state;
 109         /* on OpenBSD, this does not need _seed(), or _stir() calls */
 110         return (long)arc4random_uniform((uint32_t)x);
 111 }
 112
 113 #else
 114
 115 /* not much to remember for NSS since we use its pk11_random, placeholder */
 116 struct ub_randstate {
 117         int ready;
 118 };
 119
 120 void ub_systemseed(unsigned int ATTR_UNUSED(seed))
 121 {
 122 }
 123
 124 struct ub_randstate* ub_initstate(unsigned int ATTR_UNUSED(seed),
 125         struct ub_randstate* ATTR_UNUSED(from))
 126 {
 127         struct ub_randstate* s = (struct ub_randstate*)calloc(1, sizeof(*s));
 128         if(!s) {
 129                 log_err("malloc failure in random init");
 130                 return NULL;
 131         }
 132         return s;
 133 }
 134
 135 long int ub_random(struct ub_randstate* ATTR_UNUSED(state))
 136 {
 137         long int x;
 138         /* random 31 bit value. */
 139         SECStatus s = PK11_GenerateRandom((unsigned char*)&x, (int)sizeof(x));
 140         if(s != SECSuccess) {
 141                 log_err("PK11_GenerateRandom error: %s",
 142                         PORT_ErrorToString(PORT_GetError()));
 143         }
 144         return x & MAX_VALUE;
 145 }
 146
 147 long int
 148 ub_random_max(struct ub_randstate* state, long int x)
 149 {
 150         /* make sure we fetch in a range that is divisible by x. ignore
 151          * values from d .. MAX_VALUE, instead draw a new number */
 152         long int d = MAX_VALUE - (MAX_VALUE % x); /* d is divisible by x */
 153         long int v = ub_random(state);
 154         while(d <= v)
 155                 v = ub_random(state);
 156         return (v % x);
 157 }
 158 #endif /* HAVE_NSS */
 159
 160 void
 161 ub_randfree(struct ub_randstate* s)
 162 {
 163         if(s)
 164                 free(s);
 165         /* user app must do RAND_cleanup(); */
 166 }