1 /*****************************************************************************
2 * rand.c : non-predictible random bytes generator
3 *****************************************************************************
4 * Copyright © 2007 Rémi Denis-Courmont
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
20 *****************************************************************************/
26 #include <vlc_common.h>
34 #include <sys/types.h>
43 * Pseudo-random number generator using a HMAC-MD5 in counter mode.
44 * Probably not very secure (expert patches welcome) but definitely
45 * better than rand() which is defined to be reproducible...
49 static uint8_t okey[BLOCK_SIZE], ikey[BLOCK_SIZE];
51 static void vlc_rand_init (void)
53 #if defined (__OpenBSD__) || defined (__OpenBSD_kernel__)
54 static const char randfile[] = "/dev/random";
56 static const char randfile[] = "/dev/urandom";
58 uint8_t key[BLOCK_SIZE];
60 /* Get non-predictible value as key for HMAC */
61 int fd = vlc_open (randfile, O_RDONLY);
65 for (size_t i = 0; i < sizeof (key);)
67 ssize_t val = read (fd, key + i, sizeof (key) - i);
72 /* Precompute outer and inner keys for HMAC */
73 for (size_t i = 0; i < sizeof (key); i++)
75 okey[i] = key[i] ^ 0x5c;
76 ikey[i] = key[i] ^ 0x36;
83 void vlc_rand_bytes (void *buf, size_t len)
85 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
86 static uint64_t counter = 0;
88 uint64_t stamp = NTPtime64 ();
93 struct md5_s mdi, mdo;
98 pthread_mutex_lock (&lock);
103 AddMD5 (&mdi, ikey, sizeof (ikey));
104 AddMD5 (&mdo, okey, sizeof (okey));
105 pthread_mutex_unlock (&lock);
107 AddMD5 (&mdi, &stamp, sizeof (stamp));
108 AddMD5 (&mdi, &val, sizeof (val));
110 AddMD5 (&mdo, mdi.p_digest, sizeof (mdi.p_digest));
113 if (len < sizeof (mdo.p_digest))
115 memcpy (buf, mdo.p_digest, len);
119 memcpy (buf, mdo.p_digest, sizeof (mdo.p_digest));
120 len -= sizeof (mdo.p_digest);
121 buf = ((uint8_t *)buf) + sizeof (mdo.p_digest);
127 #include <wincrypt.h>
129 void vlc_rand_bytes (void *buf, size_t len)
133 uint8_t *p_buf = (uint8_t *)buf;
135 /* fill buffer with pseudo-random data */
140 if (count < sizeof (val))
142 memcpy (p_buf, &val, count);
146 memcpy (p_buf, &val, sizeof (val));
147 count -= sizeof (val);
148 p_buf += sizeof (val);
151 /* acquire default encryption context */
152 if( CryptAcquireContext(
153 &hProv, // Variable to hold returned handle.
154 NULL, // Use default key container.
155 MS_DEF_PROV, // Use default CSP.
156 PROV_RSA_FULL, // Type of provider to acquire.
159 /* fill buffer with pseudo-random data, intial buffer content
160 is used as auxillary random seed */
161 CryptGenRandom(hProv, len, buf);
162 CryptReleaseContext(hProv, 0);
170 unsigned short subi[3];
172 } rand48 = { false, { 0, 0, 0, }, VLC_STATIC_MUTEX, };
174 static void init_rand48 (void)
178 vlc_rand_bytes (rand48.subi, sizeof (rand48.subi));
180 #if 0 // short would be more than 16-bits ?
181 for (unsigned i = 0; i < 3; i++)
188 * PRNG uniformly distributed between 0.0 and 1.0 with 48-bits precision.
190 * @note Contrary to POSIX drand48(), this function is thread-safe.
191 * @warning Series generated by this function are not reproducible.
192 * Use erand48() if you need reproducible series.
194 * @return a double value within [0.0, 1.0] inclusive
196 double vlc_drand48 (void)
200 vlc_mutex_lock (&rand48.lock);
202 ret = erand48 (rand48.subi);
203 vlc_mutex_unlock (&rand48.lock);
208 * PRNG uniformly distributed between 0 and 2^32 - 1.
210 * @note Contrary to POSIX lrand48(), this function is thread-safe.
211 * @warning Series generated by this function are not reproducible.
212 * Use nrand48() if you need reproducible series.
214 * @return an integral value within [0.0, 2^32-1] inclusive
216 long vlc_lrand48 (void)
220 vlc_mutex_lock (&rand48.lock);
222 ret = nrand48 (rand48.subi);
223 vlc_mutex_unlock (&rand48.lock);
228 * PRNG uniformly distributed between -2^32 and 2^32 - 1.
230 * @note Contrary to POSIX mrand48(), this function is thread-safe.
231 * @warning Series generated by this function are not reproducible.
232 * Use jrand48() if you need reproducible series.
234 * @return an integral value within [-2^32, 2^32-1] inclusive
236 long vlc_mrand48 (void)
240 vlc_mutex_lock (&rand48.lock);
242 ret = jrand48 (rand48.subi);
243 vlc_mutex_unlock (&rand48.lock);