src/des/new_rnd_key.c

   1 /*
   2  * Copyright 1988 by the Massachusetts Institute of Technology.
   3  *
   4  * For copying and distribution information, please see the file
   5  * <mit-cpyright.h>.
   6  *
   7  * New pseudo-random key generator, using DES encryption to make the
   8  * pseudo-random cycle as hard to break as DES.
   9  *
  10  * Written by Mark Lillibridge, MIT Project Athena
  11  *
  12  * Under U.S. law, this software may not be exported outside the US
  13  * without license from the U.S. Commerce department.
  14  */
  15
  16 #include "mit-cpyright.h"
  17
  18 #include <afsconfig.h>
  19 #include <afs/param.h>
  20
  21
  22 #ifndef KERNEL
  23 #include <stdio.h>
  24 #endif
  25 #include "des.h"
  26 #include "des_internal.h"
  27 #include "des_prototypes.h"
  28
  29 #ifdef AFS_PTHREAD_ENV
  30 #include <pthread.h>
  31 #endif
  32 #ifdef HAVE_STRING_H
  33 #include <string.h>
  34 #else
  35 #ifdef HAVE_STRINGS_H
  36 #include <strings.h>
  37 #endif
  38 #endif
  39
  40 static afs_int32 des_set_sequence_number(des_cblock new_sequence_number);
  41 static afs_int32 des_generate_random_block(des_cblock block);
  42
  43 #define XPRT_NEW_RND_KEY
  44
  45 static int is_inited = 0;
  46 #ifdef AFS_PTHREAD_ENV
  47 /*
  48  * This mutex protects the following global variables:
  49  * is_inited
  50  */
  51
  52 #include <assert.h>
  53 pthread_mutex_t des_init_mutex
  54 #ifdef PTHREAD_MUTEX_INITIALIZER
  55 = PTHREAD_MUTEX_INITIALIZER
  56 #endif
  57 ;
  58 #define LOCK_INIT assert(pthread_mutex_lock(&des_init_mutex)==0)
  59 #define UNLOCK_INIT assert(pthread_mutex_unlock(&des_init_mutex)==0)
  60 #else
  61 #define LOCK_INIT
  62 #define UNLOCK_INIT
  63 #endif
  64 /*
  65  * des_random_key: create a random des key
  66  *
  67  * You should call des_set_random_number_generater_seed at least
  68  * once before this routine is called.  If you haven't, I'll try
  69  * to add a little randomness to the start point anyway.  Yes,
  70  * it recurses.  Deal with it.
  71  *
  72  * Notes: the returned key has correct parity and is guarenteed not
  73  *        to be a weak des key.  Des_generate_random_block is used to
  74  *        provide the random bits.
  75  */
  76 int
  77 des_random_key(des_cblock key)
  78 {
  79     LOCK_INIT;
  80     if (!is_inited) {
  81         des_init_random_number_generator(key);
  82     }
  83     UNLOCK_INIT;
  84     do {
  85         des_generate_random_block(key);
  86         des_fixup_key_parity(key);
  87     } while (des_is_weak_key(key));
  88
  89     return (0);
  90 }
  91
  92 /*
  93  * des_init_random_number_generator:
  94  *
  95  *    This routine takes a secret key possibly shared by a number
  96  * of servers and uses it to generate a random number stream that is
  97  * not shared by any of the other servers.  It does this by using the current
  98  * process id, host id, and the current time to the nearest second.  The
  99  * resulting stream seed is not useful information for cracking the secret
 100  * key.   Moreover, this routine keeps no copy of the secret key.
 101  * This routine is used for example, by the kerberos server(s) with the
 102  * key in question being the kerberos master key.
 103  *
 104  * Note: this routine calls des_set_random_generator_seed.
 105  */
 106 #if !defined(BSDUNIX) && !defined(AFS_SGI_ENV) && !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
 107 you lose ... (aka, you get to implement an analog of this for your system ...)
 108 #else
 109
 110 #ifdef AFS_NT40_ENV
 111 #include <winsock2.h>
 112 #include <process.h>
 113 #include <afs/afsutil.h>
 114 #else
 115 #include <sys/time.h>
 116 #include <unistd.h>
 117 #endif
 118
 119 void
 120 des_init_random_number_generator(des_cblock key)
 121 {
 122     struct {                    /* This must be 64 bits exactly */
 123         afs_int32 process_id;
 124         afs_int32 host_id;
 125     } seed;
 126     struct timeval time;        /* this must also be 64 bits exactly */
 127     des_cblock new_key;
 128
 129     is_inited = 1;
 130     /*
 131      * use a host id and process id in generating the seed to ensure
 132      * that different servers have different streams:
 133      */
 134 #if !defined(AFS_HPUX_ENV) && !defined(AFS_NT40_ENV)
 135     seed.host_id = gethostid();
 136 #endif
 137     seed.process_id = getpid();
 138
 139     /*
 140      * Generate a tempory value that depends on the key, host_id, and
 141      * process_id such that it gives no useful information about the key:
 142      */
 143     des_set_random_generator_seed(key);
 144     des_set_sequence_number((unsigned char *)&seed);
 145     des_random_key(new_key);
 146
 147     /*
 148      * use it to select a random stream:
 149      */
 150     des_set_random_generator_seed(new_key);
 151
 152     /*
 153      * use a time stamp to ensure that a server started later does not reuse
 154      * an old stream:
 155      */
 156     gettimeofday(&time, NULL);
 157     des_set_sequence_number((unsigned char *)&time);
 158
 159     /*
 160      * use the time stamp finally to select the final seed using the
 161      * current random number stream:
 162      */
 163     des_random_key(new_key);
 164     des_set_random_generator_seed(new_key);
 165 }
 166
 167 #endif /* ifdef BSDUNIX */
 168
 169 /*
 170  * This module implements a random number generator faculty such that the next
 171  * number in any random number stream is very hard to predict without knowing
 172  * the seed for that stream even given the preceeding random numbers.
 173  */
 174
 175 /*
 176  * The secret des key schedule for the current stream of random numbers:
 177  */
 178 static union {
 179     afs_int32 align;
 180     des_key_schedule d;
 181 } random_sequence_key;
 182
 183 /*
 184  * The sequence # in the current stream of random numbers:
 185  */
 186 static unsigned char sequence_number[8];
 187
 188 #ifdef AFS_PTHREAD_ENV
 189 /*
 190  * This mutex protects the following global variables:
 191  * random_sequence_key
 192  * sequence_number
 193  */
 194
 195 #include <assert.h>
 196 pthread_mutex_t des_random_mutex
 197 #ifdef PTHREAD_MUTEX_INITIALIZER
 198 = PTHREAD_MUTEX_INITIALIZER
 199 #endif
 200 ;
 201 #define LOCK_RANDOM assert(pthread_mutex_lock(&des_random_mutex)==0)
 202 #define UNLOCK_RANDOM assert(pthread_mutex_unlock(&des_random_mutex)==0)
 203 #else
 204 #define LOCK_RANDOM
 205 #define UNLOCK_RANDOM
 206 #endif
 207
 208 /*
 209  * des_set_random_generator_seed: this routine is used to select a random
 210  *                                number stream.  The stream that results is
 211  *                                totally determined by the passed in key.
 212  *                                (I.e., calling this routine again with the
 213  *                                same key allows repeating a sequence of
 214  *                                random numbers)
 215  *
 216  * Requires: key is a valid des key.  I.e., has correct parity and is not a
 217  *           weak des key.
 218  */
 219 void
 220 des_set_random_generator_seed(des_cblock key)
 221 {
 222     int i;
 223
 224     /* select the new stream: (note errors are not possible here...) */
 225     LOCK_RANDOM;
 226     des_key_sched(key, random_sequence_key.d);
 227
 228     /* "seek" to the start of the stream: */
 229     for (i = 0; i < 8; i++)
 230         sequence_number[i] = 0;
 231     UNLOCK_RANDOM;
 232 }
 233
 234 /*
 235  * des_set_sequence_number: this routine is used to set the sequence number
 236  *                          of the current random number stream.  This routine
 237  *                          may be used to "seek" within the current random
 238  *                          number stream.
 239  *
 240  * Note that des_set_random_generator_seed resets the sequence number to 0.
 241  */
 242 static afs_int32
 243 des_set_sequence_number(des_cblock new_sequence_number)
 244 {
 245     LOCK_RANDOM;
 246     memcpy((char *)sequence_number, (char *)new_sequence_number,
 247            sizeof(sequence_number));
 248     UNLOCK_RANDOM;
 249     return 0;
 250 }
 251
 252 /*
 253  * des_generate_random_block: routine to return the next random number
 254  *                            from the current random number stream.
 255  *                            The returned number is 64 bits long.
 256  *
 257  * Requires: des_set_random_generator_seed must have been called at least once
 258  *           before this routine is called.
 259  */
 260 static afs_int32
 261 des_generate_random_block(des_cblock block)
 262 {
 263     int i;
 264
 265     /*
 266      * Encrypt the sequence number to get the new random block:
 267      */
 268     LOCK_RANDOM;
 269     des_ecb_encrypt(sequence_number, block, random_sequence_key.d, 1);
 270
 271     /*
 272      * Increment the sequence number as an 8 byte unsigned number with wrap:
 273      * (using LSB here)
 274      */
 275     for (i = 0; i < 8; i++) {
 276         sequence_number[i] = (sequence_number[i] + 1) & 0xff;
 277         if (sequence_number[i])
 278             break;
 279     }
 280     UNLOCK_RANDOM;
 281     return 0;
 282 }