package/xorg/mcookie.c

   1 /* mcookie.c -- Generates random numbers for xauth
   2  * Created: Fri Feb  3 10:42:48 1995 by faith@cs.unc.edu
   3  * Revised: Fri Mar 19 07:48:01 1999 by faith@acm.org
   4  * Public Domain 1995, 1999 Rickard E. Faith (faith@acm.org)
   5  * This program comes with ABSOLUTELY NO WARRANTY.
   6  *
   7  * $Id: mcookie.c,v 1.5 1997/07/06 00:13:06 aebr Exp $
   8  *
   9  * This program gathers some random bits of data and used the MD5
  10  * message-digest algorithm to generate a 128-bit hexadecimal number for
  11  * use with xauth(1).
  12  *
  13  * NOTE: Unless /dev/random is available, this program does not actually
  14  * gather 128 bits of random information, so the magic cookie generated
  15  * will be considerably easier to guess than one might expect.
  16  *
  17  * 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@pld.ORG.PL>
  18  * - added Native Language Support
  19  * 1999-03-21 aeb: Added some fragments of code from Colin Plumb.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <fcntl.h>
  26 #include <sys/time.h>
  27 #include <time.h>
  28 #include <unistd.h>
  29
  30 #define BUFFERSIZE 4096
  31
  32
  33 #ifndef MD5_H
  34 #define MD5_H
  35
  36 #if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__)
  37 typedef unsigned int uint32;
  38 #else
  39 typedef unsigned long uint32;
  40 #endif
  41
  42 struct MD5Context {
  43         uint32 buf[4];
  44         uint32 bits[2];
  45         unsigned char in[64];
  46 };
  47
  48 void MD5Init(struct MD5Context *context);
  49 void MD5Update(struct MD5Context *context, unsigned char const *buf,
  50                unsigned len);
  51 void MD5Final(unsigned char digest[16], struct MD5Context *context);
  52 void MD5Transform(uint32 buf[4], uint32 const in[16]);
  53
  54 /*
  55  * This is needed to make RSAREF happy on some MS-DOS compilers.
  56  */
  57 typedef struct MD5Context MD5_CTX;
  58
  59 #endif /* !MD5_H */
  60
  61
  62
  63 /*
  64  * This code implements the MD5 message-digest algorithm.
  65  * The algorithm is due to Ron Rivest.  This code was
  66  * written by Colin Plumb in 1993, no copyright is claimed.
  67  * This code is in the public domain; do with it what you wish.
  68  *
  69  * Equivalent code is available from RSA Data Security, Inc.
  70  * This code has been tested against that, and is equivalent,
  71  * except that you don't need to include two pages of legalese
  72  * with every copy.
  73  *
  74  * To compute the message digest of a chunk of bytes, declare an
  75  * MD5Context structure, pass it to MD5Init, call MD5Update as
  76  * needed on buffers full of bytes, and then call MD5Final, which
  77  * will fill a supplied 16-byte array with the digest.
  78  */
  79 #include <string.h>             /* for memcpy() */
  80 #include <endian.h>
  81
  82 #if __BYTE_ORDER == __LITTLE_ENDIAN
  83 #define byteReverse(buf, len)   /* Nothing */
  84 #else
  85 void byteReverse(unsigned char *buf, unsigned longs);
  86
  87 /*
  88  * Note: this code is harmless on little-endian machines.
  89  */
  90 void byteReverse(unsigned char *buf, unsigned longs)
  91 {
  92     uint32 t;
  93     do {
  94         t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
  95             ((unsigned) buf[1] << 8 | buf[0]);
  96         *(uint32 *) buf = t;
  97         buf += 4;
  98     } while (--longs);
  99 }
 100 #endif
 101
 102 /*
 103  * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
 104  * initialization constants.
 105  */
 106 void MD5Init(struct MD5Context *ctx)
 107 {
 108     ctx->buf[0] = 0x67452301;
 109     ctx->buf[1] = 0xefcdab89;
 110     ctx->buf[2] = 0x98badcfe;
 111     ctx->buf[3] = 0x10325476;
 112
 113     ctx->bits[0] = 0;
 114     ctx->bits[1] = 0;
 115 }
 116
 117 /*
 118  * Update context to reflect the concatenation of another buffer full
 119  * of bytes.
 120  */
 121 void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
 122 {
 123     uint32 t;
 124
 125     /* Update bitcount */
 126
 127     t = ctx->bits[0];
 128     if ((ctx->bits[0] = t + ((uint32) len << 3)) < t)
 129         ctx->bits[1]++;         /* Carry from low to high */
 130     ctx->bits[1] += len >> 29;
 131
 132     t = (t >> 3) & 0x3f;        /* Bytes already in shsInfo->data */
 133
 134     /* Handle any leading odd-sized chunks */
 135
 136     if (t) {
 137         unsigned char *p = (unsigned char *) ctx->in + t;
 138
 139         t = 64 - t;
 140         if (len < t) {
 141             memcpy(p, buf, len);
 142             return;
 143         }
 144         memcpy(p, buf, t);
 145         byteReverse(ctx->in, 16);
 146         MD5Transform(ctx->buf, (uint32 *) ctx->in);
 147         buf += t;
 148         len -= t;
 149     }
 150     /* Process data in 64-byte chunks */
 151
 152     while (len >= 64) {
 153         memcpy(ctx->in, buf, 64);
 154         byteReverse(ctx->in, 16);
 155         MD5Transform(ctx->buf, (uint32 *) ctx->in);
 156         buf += 64;
 157         len -= 64;
 158     }
 159
 160     /* Handle any remaining bytes of data. */
 161
 162     memcpy(ctx->in, buf, len);
 163 }
 164
 165 /*
 166  * Final wrapup - pad to 64-byte boundary with the bit pattern
 167  * 1 0* (64-bit count of bits processed, MSB-first)
 168  */
 169 void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
 170 {
 171     unsigned count;
 172     unsigned char *p;
 173
 174     /* Compute number of bytes mod 64 */
 175     count = (ctx->bits[0] >> 3) & 0x3F;
 176
 177     /* Set the first char of padding to 0x80.  This is safe since there is
 178        always at least one byte free */
 179     p = ctx->in + count;
 180     *p++ = 0x80;
 181
 182     /* Bytes of padding needed to make 64 bytes */
 183     count = 64 - 1 - count;
 184
 185     /* Pad out to 56 mod 64 */
 186     if (count < 8) {
 187         /* Two lots of padding:  Pad the first block to 64 bytes */
 188         memset(p, 0, count);
 189         byteReverse(ctx->in, 16);
 190         MD5Transform(ctx->buf, (uint32 *) ctx->in);
 191
 192         /* Now fill the next block with 56 bytes */
 193         memset(ctx->in, 0, 56);
 194     } else {
 195         /* Pad block to 56 bytes */
 196         memset(p, 0, count - 8);
 197     }
 198     byteReverse(ctx->in, 14);
 199
 200     /* Append length in bits and transform */
 201     ((uint32 *) ctx->in)[14] = ctx->bits[0];
 202     ((uint32 *) ctx->in)[15] = ctx->bits[1];
 203
 204     MD5Transform(ctx->buf, (uint32 *) ctx->in);
 205     byteReverse((unsigned char *) ctx->buf, 4);
 206     memcpy(digest, ctx->buf, 16);
 207     memset(ctx, 0, sizeof(ctx));        /* In case it's sensitive */
 208 }
 209
 210 /* The four core functions - F1 is optimized somewhat */
 211
 212 /* #define F1(x, y, z) (x & y | ~x & z) */
 213 #define F1(x, y, z) (z ^ (x & (y ^ z)))
 214 #define F2(x, y, z) F1(z, x, y)
 215 #define F3(x, y, z) (x ^ y ^ z)
 216 #define F4(x, y, z) (y ^ (x | ~z))
 217
 218 /* This is the central step in the MD5 algorithm. */
 219 #define MD5STEP(f, w, x, y, z, data, s) \
 220         ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
 221
 222 /*
 223  * The core of the MD5 algorithm, this alters an existing MD5 hash to
 224  * reflect the addition of 16 longwords of new data.  MD5Update blocks
 225  * the data and converts bytes into longwords for this routine.
 226  */
 227 void MD5Transform(uint32 buf[4], uint32 const in[16])
 228 {
 229     register uint32 a, b, c, d;
 230
 231     a = buf[0];
 232     b = buf[1];
 233     c = buf[2];
 234     d = buf[3];
 235
 236     MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
 237     MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
 238     MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
 239     MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
 240     MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
 241     MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
 242     MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
 243     MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
 244     MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
 245     MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
 246     MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
 247     MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
 248     MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
 249     MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
 250     MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
 251     MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
 252
 253     MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
 254     MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
 255     MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
 256     MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
 257     MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
 258     MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
 259     MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
 260     MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
 261     MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
 262     MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
 263     MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
 264     MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
 265     MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
 266     MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
 267     MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
 268     MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
 269
 270     MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
 271     MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
 272     MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
 273     MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
 274     MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
 275     MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
 276     MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
 277     MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
 278     MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
 279     MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
 280     MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
 281     MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
 282     MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
 283     MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
 284     MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
 285     MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
 286
 287     MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
 288     MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
 289     MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
 290     MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
 291     MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
 292     MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
 293     MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
 294     MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
 295     MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
 296     MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
 297     MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
 298     MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
 299     MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
 300     MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
 301     MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
 302     MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
 303
 304     buf[0] += a;
 305     buf[1] += b;
 306     buf[2] += c;
 307     buf[3] += d;
 308 }
 309
 310
 311
 312
 313 struct rngs {
 314    const char *path;
 315    int minlength, maxlength;
 316 } rngs[] = {
 317    { "/dev/random",              16,  16 }, /* 16 bytes = 128 bits suffice */
 318    { "/proc/interrupts",          0,   0 },
 319    { "/proc/slabinfo",            0,   0 },
 320    { "/proc/stat",                0,   0 },
 321    { "/dev/urandom",             32,  64 },
 322 };
 323 #define RNGS (sizeof(rngs)/sizeof(struct rngs))
 324
 325 int Verbose = 0;
 326
 327 /* The basic function to hash a file */
 328 static off_t
 329 hash_file(struct MD5Context *ctx, int fd)
 330 {
 331    off_t count = 0;
 332    ssize_t r;
 333    unsigned char buf[BUFFERSIZE];
 334
 335    while ((r = read(fd, buf, sizeof(buf))) > 0) {
 336       MD5Update(ctx, buf, r);
 337       count += r;
 338    }
 339    /* Separate files with a null byte */
 340    buf[0] = 0;
 341    MD5Update(ctx, buf, 1);
 342    return count;
 343 }
 344
 345 int main( int argc, char **argv )
 346 {
 347    int               i;
 348    struct MD5Context ctx;
 349    unsigned char     digest[16];
 350    unsigned char     buf[BUFFERSIZE];
 351    int               fd;
 352    int               c;
 353    pid_t             pid;
 354    char              *file = NULL;
 355    int               r;
 356    struct timeval    tv;
 357    struct timezone   tz;
 358
 359    while ((c = getopt( argc, argv, "vf:" )) != -1)
 360       switch (c) {
 361       case 'v': ++Verbose;     break;
 362       case 'f': file = optarg; break;
 363       }
 364
 365    MD5Init( &ctx );
 366
 367    gettimeofday( &tv, &tz );
 368    MD5Update( &ctx, (unsigned char *)&tv, sizeof( tv ) );
 369    pid = getppid();
 370    MD5Update( &ctx, (unsigned char *)&pid, sizeof( pid ));
 371    pid = getpid();
 372    MD5Update( &ctx, (unsigned char *)&pid, sizeof( pid ));
 373
 374    if (file) {
 375       int count = 0;
 376
 377       if (file[0] == '-' && !file[1])
 378          fd = fileno(stdin);
 379       else
 380          fd = open( file, O_RDONLY );
 381
 382       if (fd < 0) {
 383          fprintf( stderr, "Could not open %s\n", file );
 384       } else {
 385          count = hash_file( &ctx, fd );
 386          if (Verbose)
 387             fprintf( stderr, "Got %d bytes from %s\n", count, file );
 388
 389          if (file[0] != '-' || file[1]) close( fd );
 390       }
 391    }
 392
 393    for (i = 0; i < RNGS; i++) {
 394       if ((fd = open( rngs[i].path, O_RDONLY|O_NONBLOCK )) >= 0) {
 395          int count = sizeof(buf);
 396
 397          if (rngs[i].maxlength && count > rngs[i].maxlength)
 398             count = rngs[i].maxlength;
 399          r = read( fd, buf, count );
 400          if (r > 0)
 401             MD5Update( &ctx, buf, r );
 402          else
 403             r = 0;
 404          close( fd );
 405          if (Verbose)
 406             fprintf( stderr, "Got %d bytes from %s\n", r, rngs[i].path );
 407          if (rngs[i].minlength && r >= rngs[i].minlength)
 408             break;
 409       } else if (Verbose)
 410          fprintf( stderr, "Could not open %s\n", rngs[i].path );
 411    }
 412
 413    MD5Final( digest, &ctx );
 414    for (i = 0; i < 16; i++) printf( "%02x", digest[i] );
 415    putchar ( '\n' );
 416
 417    /*
 418     * The following is important for cases like disk full, so shell scripts
 419     * can bomb out properly rather than think they succeeded.
 420     */
 421    if (fflush(stdout) < 0 || fclose(stdout) < 0)
 422       return 1;
 423
 424    return 0;
 425 }