2 * Copyright (c) 1995, 1996, 1997, 1999 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the Institute nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 RCSID("$Id: rnd_keys.c 17445 2006-05-05 10:37:46Z lha $");
41 #include <krb5-types.h>
48 #ifdef TIME_WITH_SYS_TIME
51 #elif defined(HAVE_SYS_TIME_H)
57 #ifdef HAVE_SYS_TYPES_H
58 #include <sys/types.h>
76 * Generate "random" data by checksumming a file.
78 * Returns -1 if there were any problems with permissions or I/O
83 sumFile (const char *name, int len, void *res)
85 uint32_t sum[2] = { 0, 0 };
95 int n = read(fd, buf, sizeof(buf));
101 for (i = 0; i < (n/sizeof(buf[0])); i++)
110 memcpy (res, &sum, sizeof(sum));
117 md5sumFile (const char *name, int len, int32_t sum[4])
130 int n = read(fd, buf, sizeof(buf));
136 md5_update(&md5, buf, n);
139 md5_finito(&md5, (unsigned char *)sum);
146 * Create a sequence of random 64 bit blocks.
147 * The sequence is indexed with a long long and
148 * based on an initial des key used as a seed.
150 static DES_key_schedule sequence_seed;
151 static uint32_t sequence_index[2];
154 * Random number generator based on ideas from truerand in cryptolib
155 * as described on page 424 in Applied Cryptography 2 ed. by Bruce
159 static volatile int counter;
160 static volatile unsigned char *gdata; /* Global data */
161 static volatile int igdata; /* Index into global data */
164 #if !defined(WIN32) && !defined(__EMX__) && !defined(__OS2__) && !defined(__CYGWIN32__)
165 /* Visual C++ 4.0 (Windows95/NT) */
172 gdata[igdata++] ^= counter & 0xff;
174 #ifndef HAVE_SIGACTION
175 signal(SIGALRM, sigALRM); /* Reinstall SysV signal handler */
182 #if !defined(HAVE_RANDOM) && defined(HAVE_RAND)
184 #define srandom srand
191 #if !defined(HAVE_SETITIMER) || defined(WIN32) || defined(__EMX__) || defined(__OS2__) || defined(__CYGWIN32__)
193 des_not_rand_data(unsigned char *data, int size)
197 srandom (time (NULL));
199 for(i = 0; i < size; ++i)
200 data[i] ^= random() % 0x100;
204 #if !defined(WIN32) && !defined(__EMX__) && !defined(__OS2__) && !defined(__CYGWIN32__)
206 #ifndef HAVE_SETITIMER
208 pacemaker(struct timeval *tv)
216 select(1, &fds, NULL, NULL, tv);
222 #ifdef HAVE_SIGACTION
223 /* XXX ugly hack, should perhaps use function from roken */
225 (*fake_signal(int sig, RETSIGTYPE (*f)(int)))(int)
227 struct sigaction sa, osa;
230 sigemptyset(&sa.sa_mask);
231 sigaction(sig, &sa, &osa);
232 return osa.sa_handler;
234 #define signal(S, F) fake_signal((S), (F))
238 * Generate size bytes of "random" data using timed interrupts.
239 * It takes about 40ms/byte random data.
240 * It's not neccessary to be root to run it.
243 DES_rand_data(void *outdata, int size)
245 unsigned char *data = outdata;
246 struct itimerval tv, otv;
247 RETSIGTYPE (*osa)(int);
249 #ifndef HAVE_SETITIMER
250 RETSIGTYPE (*ochld)(int);
253 const char *rnd_devices[] = {"/dev/random",
260 for(p = rnd_devices; *p; p++) {
261 int fd = open(*p, O_RDONLY | O_NDELAY);
263 if(fd >= 0 && read(fd, data, size) == size) {
270 /* Paranoia? Initialize data from /dev/mem if we can read it. */
272 sumFile("/dev/mem", (1024*1024*2), data);
278 osa = signal(SIGALRM, sigALRM);
281 tv.it_value.tv_sec = 0;
282 tv.it_value.tv_usec = 10 * 1000; /* 10 ms */
283 tv.it_interval = tv.it_value;
284 #ifdef HAVE_SETITIMER
285 setitimer(ITIMER_REAL, &tv, &otv);
287 ochld = signal(SIGCHLD, SIG_IGN);
290 signal(SIGCHLD, ochld != SIG_ERR ? ochld : SIG_DFL);
291 des_not_rand_data(data, size);
295 pacemaker(&tv.it_interval);
298 for(i = 0; i < 4; i++) {
299 for (igdata = 0; igdata < size;) /* igdata++ in sigALRM */
301 for (j = 0; j < size; j++) /* Only use 2 bits each lap */
302 gdata[j] = (gdata[j]>>2) | (gdata[j]<<6);
304 #ifdef HAVE_SETITIMER
305 setitimer(ITIMER_REAL, &otv, 0);
308 while(waitpid(pid, NULL, 0) != pid);
309 signal(SIGCHLD, ochld != SIG_ERR ? ochld : SIG_DFL);
311 signal(SIGALRM, osa != SIG_ERR ? osa : SIG_DFL);
315 DES_rand_data(unsigned char *p, int s)
317 des_not_rand_data (p, s);
322 DES_generate_random_block(DES_cblock *block)
324 DES_rand_data((unsigned char *)block, sizeof(*block));
327 #define DES_rand_data_key hc_DES_rand_data_key
330 DES_rand_data_key(DES_cblock *key);
333 * Generate a "random" DES key.
336 DES_rand_data_key(DES_cblock *key)
338 unsigned char data[8];
339 DES_key_schedule sched;
341 DES_rand_data(data, sizeof(data));
342 DES_rand_data((unsigned char*)key, sizeof(DES_cblock));
343 DES_set_odd_parity(key);
344 DES_set_key(key, &sched);
345 DES_ecb_encrypt(&data, key, &sched, DES_ENCRYPT);
346 memset(&data, 0, sizeof(data));
347 memset(&sched, 0, sizeof(sched));
348 DES_set_odd_parity(key);
349 } while(DES_is_weak_key(key));
353 * Generate "random" data by checksumming /dev/mem
355 * It's neccessary to be root to run it. Returns -1 if there were any
356 * problems with permissions.
359 #define DES_mem_rand8 hc_DES_mem_rand8
362 DES_mem_rand8(unsigned char *data);
365 DES_mem_rand8(unsigned char *data)
371 * In case the generator does not get initialized use this as fallback.
373 static int initialized;
378 DES_cblock default_seed;
380 DES_generate_random_block(&default_seed);
381 DES_set_odd_parity(&default_seed);
382 } while (DES_is_weak_key(&default_seed));
383 DES_init_random_number_generator(&default_seed);
386 #define zero_long_long(ll) do { ll[0] = ll[1] = 0; } while (0)
388 #define incr_long_long(ll) do { if (++ll[0] == 0) ++ll[1]; } while (0)
390 #define set_sequence_number(ll) \
391 memcpy((char *)sequence_index, (ll), sizeof(sequence_index));
394 * Set the sequnce number to this value (a long long).
397 DES_set_sequence_number(void *ll)
399 set_sequence_number(ll);
403 * Set the generator seed and reset the sequence number to 0.
406 DES_set_random_generator_seed(DES_cblock *seed)
408 DES_set_key(seed, &sequence_seed);
409 zero_long_long(sequence_index);
414 * Generate a sequence of random des keys
415 * using the random block sequence, fixup
416 * parity and skip weak keys.
419 DES_new_random_key(DES_cblock *key)
425 DES_ecb_encrypt((DES_cblock *) sequence_index,
429 incr_long_long(sequence_index);
430 /* random key must have odd parity and not be weak */
431 DES_set_odd_parity(key);
432 } while (DES_is_weak_key(key));
437 * des_init_random_number_generator:
439 * Initialize the sequence of random 64 bit blocks. The input seed
440 * can be a secret key since it should be well hidden and is also not
445 DES_init_random_number_generator(DES_cblock *seed)
451 gettimeofday(&now, (struct timezone *)0);
452 DES_generate_random_block(&uniq);
454 /* Pick a unique random key from the shared sequence. */
455 DES_set_random_generator_seed(seed);
456 set_sequence_number((unsigned char *)&uniq);
457 DES_new_random_key(&new_key);
459 /* Select a new nonshared sequence, */
460 DES_set_random_generator_seed(&new_key);
462 /* and use the current time to pick a key for the new sequence. */
463 set_sequence_number((unsigned char *)&now);
464 DES_new_random_key(&new_key);
465 DES_set_random_generator_seed(&new_key);
468 /* This is for backwards compatibility. */
470 DES_random_key(DES_cblock *ret)
472 DES_new_random_key(ret);
479 unsigned char data[8];
484 if (sumFile("/dev/mem", (1024*1024*8), data) != 0)
485 { perror("sumFile"); exit(1); }
486 for (i = 0; i < 8; i++)
487 printf("%02x", data[i]);
503 DES_random_key(data);
504 for (i = 0; i < 8; i++)
505 printf("%02x", data[i]);