sysvinit-md5-bigendian.patch

   1 --- sysvinit-2.77/src/md5.c.be  Fri Aug 20 14:05:19 1999
   2 +++ sysvinit-2.77/src/md5.c     Sat Jul 24 02:13:39 1999
   3 @@ -0,0 +1,256 @@
   4 +/*
   5 + * $Id$
   6 + *
   7 + * This code implements the MD5 message-digest algorithm.
   8 + * The algorithm is due to Ron Rivest.  This code was
   9 + * written by Colin Plumb in 1993, no copyright is claimed.
  10 + * This code is in the public domain; do with it what you wish.
  11 + *
  12 + * Equivalent code is available from RSA Data Security, Inc.
  13 + * This code has been tested against that, and is equivalent,
  14 + * except that you don't need to include two pages of legalese
  15 + * with every copy.
  16 + *
  17 + * To compute the message digest of a chunk of bytes, declare an
  18 + * MD5Context structure, pass it to MD5Init, call MD5Update as
  19 + * needed on buffers full of bytes, and then call MD5Final, which
  20 + * will fill a supplied 16-byte array with the digest.
  21 + *
  22 + */
  23 +
  24 +#include <string.h>
  25 +#include "md5.h"
  26 +
  27 +#ifndef HIGHFIRST
  28 +#define byteReverse(buf, len)  /* Nothing */
  29 +#else
  30 +static void byteReverse(unsigned char *buf, unsigned longs);
  31 +
  32 +#ifndef ASM_MD5
  33 +/*
  34 + * Note: this code is harmless on little-endian machines.
  35 + */
  36 +static void byteReverse(unsigned char *buf, unsigned longs)
  37 +{
  38 +       uint32 t;
  39 +       do {
  40 +               t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
  41 +                   ((unsigned) buf[1] << 8 | buf[0]);
  42 +               *(uint32 *) buf = t;
  43 +               buf += 4;
  44 +       } while (--longs);
  45 +}
  46 +#endif
  47 +#endif
  48 +
  49 +/*
  50 + * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
  51 + * initialization constants.
  52 + */
  53 +void MD5Name(MD5Init)(struct MD5Context *ctx)
  54 +{
  55 +       ctx->buf[0] = 0x67452301U;
  56 +       ctx->buf[1] = 0xefcdab89U;
  57 +       ctx->buf[2] = 0x98badcfeU;
  58 +       ctx->buf[3] = 0x10325476U;
  59 +
  60 +       ctx->bits[0] = 0;
  61 +       ctx->bits[1] = 0;
  62 +}
  63 +
  64 +/*
  65 + * Update context to reflect the concatenation of another buffer full
  66 + * of bytes.
  67 + */
  68 +void MD5Name(MD5Update)(struct MD5Context *ctx, unsigned const char *buf, unsigned len)
  69 +{
  70 +       uint32 t;
  71 +
  72 +       /* Update bitcount */
  73 +
  74 +       t = ctx->bits[0];
  75 +       if ((ctx->bits[0] = t + ((uint32) len << 3)) < t)
  76 +               ctx->bits[1]++; /* Carry from low to high */
  77 +       ctx->bits[1] += len >> 29;
  78 +
  79 +       t = (t >> 3) & 0x3f;    /* Bytes already in shsInfo->data */
  80 +
  81 +       /* Handle any leading odd-sized chunks */
  82 +
  83 +       if (t) {
  84 +               unsigned char *p = (unsigned char *) ctx->in + t;
  85 +
  86 +               t = 64 - t;
  87 +               if (len < t) {
  88 +                       memcpy(p, buf, len);
  89 +                       return;
  90 +               }
  91 +               memcpy(p, buf, t);
  92 +               byteReverse(ctx->in, 16);
  93 +               MD5Name(MD5Transform)(ctx->buf, (uint32 *) ctx->in);
  94 +               buf += t;
  95 +               len -= t;
  96 +       }
  97 +       /* Process data in 64-byte chunks */
  98 +
  99 +       while (len >= 64) {
 100 +               memcpy(ctx->in, buf, 64);
 101 +               byteReverse(ctx->in, 16);
 102 +               MD5Name(MD5Transform)(ctx->buf, (uint32 *) ctx->in);
 103 +               buf += 64;
 104 +               len -= 64;
 105 +       }
 106 +
 107 +       /* Handle any remaining bytes of data. */
 108 +
 109 +       memcpy(ctx->in, buf, len);
 110 +}
 111 +
 112 +/*
 113 + * Final wrapup - pad to 64-byte boundary with the bit pattern
 114 + * 1 0* (64-bit count of bits processed, MSB-first)
 115 + */
 116 +void MD5Name(MD5Final)(unsigned char digest[16], struct MD5Context *ctx)
 117 +{
 118 +       unsigned count;
 119 +       unsigned char *p;
 120 +
 121 +       /* Compute number of bytes mod 64 */
 122 +       count = (ctx->bits[0] >> 3) & 0x3F;
 123 +
 124 +       /* Set the first char of padding to 0x80.  This is safe since there is
 125 +          always at least one byte free */
 126 +       p = ctx->in + count;
 127 +       *p++ = 0x80;
 128 +
 129 +       /* Bytes of padding needed to make 64 bytes */
 130 +       count = 64 - 1 - count;
 131 +
 132 +       /* Pad out to 56 mod 64 */
 133 +       if (count < 8) {
 134 +               /* Two lots of padding:  Pad the first block to 64 bytes */
 135 +               memset(p, 0, count);
 136 +               byteReverse(ctx->in, 16);
 137 +               MD5Name(MD5Transform)(ctx->buf, (uint32 *) ctx->in);
 138 +
 139 +               /* Now fill the next block with 56 bytes */
 140 +               memset(ctx->in, 0, 56);
 141 +       } else {
 142 +               /* Pad block to 56 bytes */
 143 +               memset(p, 0, count - 8);
 144 +       }
 145 +       byteReverse(ctx->in, 14);
 146 +
 147 +       /* Append length in bits and transform */
 148 +       ((uint32 *) ctx->in)[14] = ctx->bits[0];
 149 +       ((uint32 *) ctx->in)[15] = ctx->bits[1];
 150 +
 151 +       MD5Name(MD5Transform)(ctx->buf, (uint32 *) ctx->in);
 152 +       byteReverse((unsigned char *) ctx->buf, 4);
 153 +       memcpy(digest, ctx->buf, 16);
 154 +       memset(ctx, 0, sizeof(ctx));    /* In case it's sensitive */
 155 +}
 156 +
 157 +#ifndef ASM_MD5
 158 +
 159 +/* The four core functions - F1 is optimized somewhat */
 160 +
 161 +/* #define F1(x, y, z) (x & y | ~x & z) */
 162 +#define F1(x, y, z) (z ^ (x & (y ^ z)))
 163 +#define F2(x, y, z) F1(z, x, y)
 164 +#define F3(x, y, z) (x ^ y ^ z)
 165 +#define F4(x, y, z) (y ^ (x | ~z))
 166 +
 167 +/* This is the central step in the MD5 algorithm. */
 168 +#define MD5STEP(f, w, x, y, z, data, s) \
 169 +       ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
 170 +
 171 +/*
 172 + * The core of the MD5 algorithm, this alters an existing MD5 hash to
 173 + * reflect the addition of 16 longwords of new data.  MD5Update blocks
 174 + * the data and converts bytes into longwords for this routine.
 175 + */
 176 +void MD5Name(MD5Transform)(uint32 buf[4], uint32 const in[16])
 177 +{
 178 +       register uint32 a, b, c, d;
 179 +
 180 +       a = buf[0];
 181 +       b = buf[1];
 182 +       c = buf[2];
 183 +       d = buf[3];
 184 +
 185 +       MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478U, 7);
 186 +       MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756U, 12);
 187 +       MD5STEP(F1, c, d, a, b, in[2] + 0x242070dbU, 17);
 188 +       MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceeeU, 22);
 189 +       MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0fafU, 7);
 190 +       MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62aU, 12);
 191 +       MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613U, 17);
 192 +       MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501U, 22);
 193 +       MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8U, 7);
 194 +       MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7afU, 12);
 195 +       MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1U, 17);
 196 +       MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7beU, 22);
 197 +       MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122U, 7);
 198 +       MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193U, 12);
 199 +       MD5STEP(F1, c, d, a, b, in[14] + 0xa679438eU, 17);
 200 +       MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821U, 22);
 201 +
 202 +       MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562U, 5);
 203 +       MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340U, 9);
 204 +       MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51U, 14);
 205 +       MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aaU, 20);
 206 +       MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105dU, 5);
 207 +       MD5STEP(F2, d, a, b, c, in[10] + 0x02441453U, 9);
 208 +       MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681U, 14);
 209 +       MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8U, 20);
 210 +       MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6U, 5);
 211 +       MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6U, 9);
 212 +       MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87U, 14);
 213 +       MD5STEP(F2, b, c, d, a, in[8] + 0x455a14edU, 20);
 214 +       MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905U, 5);
 215 +       MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8U, 9);
 216 +       MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9U, 14);
 217 +       MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8aU, 20);
 218 +
 219 +       MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942U, 4);
 220 +       MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681U, 11);
 221 +       MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122U, 16);
 222 +       MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380cU, 23);
 223 +       MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44U, 4);
 224 +       MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9U, 11);
 225 +       MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60U, 16);
 226 +       MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70U, 23);
 227 +       MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6U, 4);
 228 +       MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127faU, 11);
 229 +       MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085U, 16);
 230 +       MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05U, 23);
 231 +       MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039U, 4);
 232 +       MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5U, 11);
 233 +       MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8U, 16);
 234 +       MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665U, 23);
 235 +
 236 +       MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244U, 6);
 237 +       MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97U, 10);
 238 +       MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7U, 15);
 239 +       MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039U, 21);
 240 +       MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3U, 6);
 241 +       MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92U, 10);
 242 +       MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47dU, 15);
 243 +       MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1U, 21);
 244 +       MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4fU, 6);
 245 +       MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0U, 10);
 246 +       MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314U, 15);
 247 +       MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1U, 21);
 248 +       MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82U, 6);
 249 +       MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235U, 10);
 250 +       MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bbU, 15);
 251 +       MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391U, 21);
 252 +
 253 +       buf[0] += a;
 254 +       buf[1] += b;
 255 +       buf[2] += c;
 256 +       buf[3] += d;
 257 +}
 258 +
 259 +#endif
 260 --- sysvinit-2.77/src/md5.h.be  Fri Aug 20 14:05:22 1999
 261 +++ sysvinit-2.77/src/md5.h     Fri Aug 20 13:54:09 1999
 262 @@ -0,0 +1,40 @@
 263 +#ifndef MD5_H
 264 +#define MD5_H
 265 +
 266 +#include <features.h>
 267 +#if defined(__GLIBC__) && __GLIBC__ > 1
 268 +# include <stdint.h>
 269 +typedef uint32_t uint32;
 270 +#else
 271 +# ifdef __alpha
 272 +typedef unsigned int uint32;
 273 +# else
 274 +typedef unsigned long uint32;
 275 +# endif
 276 +#endif
 277 +
 278 +struct MD5Context {
 279 +    uint32 buf[4];
 280 +    uint32 bits[2];
 281 +    unsigned char in[64];
 282 +};
 283 +
 284 +void GoodMD5Init(struct MD5Context *);
 285 +void GoodMD5Update(struct MD5Context *, unsigned const char *, unsigned);
 286 +void GoodMD5Final(unsigned char digest[16], struct MD5Context *);
 287 +void GoodMD5Transform(uint32 buf[4], uint32 const in[16]);
 288 +void BrokenMD5Init(struct MD5Context *);
 289 +void BrokenMD5Update(struct MD5Context *, unsigned const char *, unsigned);
 290 +void BrokenMD5Final(unsigned char digest[16], struct MD5Context *);
 291 +void BrokenMD5Transform(uint32 buf[4], uint32 const in[16]);
 292 +
 293 +char *Goodcrypt_md5(const char *pw, const char *salt);
 294 +char *Brokencrypt_md5(const char *pw, const char *salt);
 295 +
 296 +/*
 297 +* This is needed to make RSAREF happy on some MS-DOS compilers.
 298 +*/
 299 +
 300 +typedef struct MD5Context MD5_CTX;
 301 +
 302 +#endif /* MD5_H */
 303 --- sysvinit-2.77/src/md5_crypt.c.be    Fri Aug 20 14:05:25 1999
 304 +++ sysvinit-2.77/src/md5_crypt.c       Sat Jul 24 02:13:39 1999
 305 @@ -0,0 +1,149 @@
 306 +/*
 307 + * $Id$
 308 + *
 309 + * ----------------------------------------------------------------------------
 310 + * "THE BEER-WARE LICENSE" (Revision 42):
 311 + * <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
 312 + * can do whatever you want with this stuff. If we meet some day, and you think
 313 + * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
 314 + * ----------------------------------------------------------------------------
 315 + *
 316 + * Origin: Id: crypt.c,v 1.3 1995/05/30 05:42:22 rgrimes Exp
 317 + *
 318 + */
 319 +
 320 +#include <string.h>
 321 +#include "md5.h"
 322 +
 323 +static unsigned char itoa64[] =        /* 0 ... 63 => ascii - 64 */
 324 +"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 325 +
 326 +static void to64(char *s, unsigned long v, int n)
 327 +{
 328 +       while (--n >= 0) {
 329 +               *s++ = itoa64[v & 0x3f];
 330 +               v >>= 6;
 331 +       }
 332 +}
 333 +
 334 +/*
 335 + * UNIX password
 336 + *
 337 + * Use MD5 for what it is best at...
 338 + */
 339 +
 340 +char *MD5Name(crypt_md5)(const char *pw, const char *salt)
 341 +{
 342 +       const char *magic = "$1$";
 343 +       /* This string is magic for this algorithm.  Having
 344 +        * it this way, we can get get better later on */
 345 +       static char passwd[120], *p;
 346 +       static const char *sp, *ep;
 347 +       unsigned char final[16];
 348 +       int sl, pl, i, j;
 349 +       MD5_CTX ctx, ctx1;
 350 +       unsigned long l;
 351 +
 352 +       /* Refine the Salt first */
 353 +       sp = salt;
 354 +
 355 +       /* If it starts with the magic string, then skip that */
 356 +       if (!strncmp(sp, magic, strlen(magic)))
 357 +               sp += strlen(magic);
 358 +
 359 +       /* It stops at the first '$', max 8 chars */
 360 +       for (ep = sp; *ep && *ep != '$' && ep < (sp + 8); ep++)
 361 +               continue;
 362 +
 363 +       /* get the length of the true salt */
 364 +       sl = ep - sp;
 365 +
 366 +       MD5Name(MD5Init)(&ctx);
 367 +
 368 +       /* The password first, since that is what is most unknown */
 369 +       MD5Name(MD5Update)(&ctx,(unsigned const char *)pw,strlen(pw));
 370 +
 371 +       /* Then our magic string */
 372 +       MD5Name(MD5Update)(&ctx,(unsigned const char *)magic,strlen(magic));
 373 +
 374 +       /* Then the raw salt */
 375 +       MD5Name(MD5Update)(&ctx,(unsigned const char *)sp,sl);
 376 +
 377 +       /* Then just as many characters of the MD5(pw,salt,pw) */
 378 +       MD5Name(MD5Init)(&ctx1);
 379 +       MD5Name(MD5Update)(&ctx1,(unsigned const char *)pw,strlen(pw));
 380 +       MD5Name(MD5Update)(&ctx1,(unsigned const char *)sp,sl);
 381 +       MD5Name(MD5Update)(&ctx1,(unsigned const char *)pw,strlen(pw));
 382 +       MD5Name(MD5Final)(final,&ctx1);
 383 +       for (pl = strlen(pw); pl > 0; pl -= 16)
 384 +               MD5Name(MD5Update)(&ctx,(unsigned const char *)final,pl>16 ? 16 : pl);
 385 +
 386 +       /* Don't leave anything around in vm they could use. */
 387 +       memset(final, 0, sizeof final);
 388 +
 389 +       /* Then something really weird... */
 390 +       for (j = 0, i = strlen(pw); i; i >>= 1)
 391 +               if (i & 1)
 392 +                       MD5Name(MD5Update)(&ctx, (unsigned const char *)final+j, 1);
 393 +               else
 394 +                       MD5Name(MD5Update)(&ctx, (unsigned const char *)pw+j, 1);
 395 +
 396 +       /* Now make the output string */
 397 +       strcpy(passwd, magic);
 398 +       strncat(passwd, sp, sl);
 399 +       strcat(passwd, "$");
 400 +
 401 +       MD5Name(MD5Final)(final,&ctx);
 402 +
 403 +       /*
 404 +        * and now, just to make sure things don't run too fast
 405 +        * On a 60 Mhz Pentium this takes 34 msec, so you would
 406 +        * need 30 seconds to build a 1000 entry dictionary...
 407 +        */
 408 +       for (i = 0; i < 1000; i++) {
 409 +               MD5Name(MD5Init)(&ctx1);
 410 +               if (i & 1)
 411 +                       MD5Name(MD5Update)(&ctx1,(unsigned const char *)pw,strlen(pw));
 412 +               else
 413 +                       MD5Name(MD5Update)(&ctx1,(unsigned const char *)final,16);
 414 +
 415 +               if (i % 3)
 416 +                       MD5Name(MD5Update)(&ctx1,(unsigned const char *)sp,sl);
 417 +
 418 +               if (i % 7)
 419 +                       MD5Name(MD5Update)(&ctx1,(unsigned const char *)pw,strlen(pw));
 420 +
 421 +               if (i & 1)
 422 +                       MD5Name(MD5Update)(&ctx1,(unsigned const char *)final,16);
 423 +               else
 424 +                       MD5Name(MD5Update)(&ctx1,(unsigned const char *)pw,strlen(pw));
 425 +               MD5Name(MD5Final)(final,&ctx1);
 426 +       }
 427 +
 428 +       p = passwd + strlen(passwd);
 429 +
 430 +       l = (final[0] << 16) | (final[6] << 8) | final[12];
 431 +       to64(p, l, 4);
 432 +       p += 4;
 433 +       l = (final[1] << 16) | (final[7] << 8) | final[13];
 434 +       to64(p, l, 4);
 435 +       p += 4;
 436 +       l = (final[2] << 16) | (final[8] << 8) | final[14];
 437 +       to64(p, l, 4);
 438 +       p += 4;
 439 +       l = (final[3] << 16) | (final[9] << 8) | final[15];
 440 +       to64(p, l, 4);
 441 +       p += 4;
 442 +       l = (final[4] << 16) | (final[10] << 8) | final[5];
 443 +       to64(p, l, 4);
 444 +       p += 4;
 445 +       l = final[11];
 446 +       to64(p, l, 2);
 447 +       p += 2;
 448 +       *p = '\0';
 449 +
 450 +       /* Don't leave anything around in vm they could use. */
 451 +       memset(final, 0, sizeof final);
 452 +
 453 +       return passwd;
 454 +}
 455 --- sysvinit-2.77/src/Makefile.be       Fri Aug 20 12:05:26 1999
 456 +++ sysvinit-2.77/src/Makefile  Fri Aug 20 14:20:42 1999
 457 @@ -50,8 +50,8 @@ utmpdump:     utmpdump.o
 458  runlevel:      runlevel.o
 459                 $(CC) $(LDFLAGS) -o $@ runlevel.o
 460
 461 -sulogin:       sulogin.o
 462 -               $(CC) $(LDFLAGS) $(STATIC) -o $@ sulogin.o $(LCRYPT)
 463 +sulogin:       sulogin.o md5_broken.o md5_crypt_broken.o
 464 +               $(CC) $(LDFLAGS) $(STATIC) -o $@ $^ $(LCRYPT)
 465
 466  wall:          dowall.o wall.o
 467                 $(CC) $(LDFLAGS) -o $@ dowall.o wall.o
 468 @@ -67,6 +67,12 @@ utmp.o:              utmp.c init.h
 469
 470  init_utmp.o:   utmp.c init.h
 471                 $(CC) -c $(CFLAGS) -DINIT_MAIN utmp.c -o init_utmp.o
 472 +
 473 +md5_broken.o: md5.c
 474 +               $(CC) $(CFLAGS) -D'MD5Name(x)=Broken##x' -c $< -o $@
 475 +
 476 +md5_crypt_broken.o: md5_crypt.c
 477 +               $(CC) $(CFLAGS) -D'MD5Name(x)=Broken##x' -c $< -o $@
 478
 479  cleanobjs:
 480                 rm -f *.o *.bak
 481 --- sysvinit-2.77/src/sulogin.c.be      Fri Aug 20 12:05:26 1999
 482 +++ sysvinit-2.77/src/sulogin.c Fri Aug 20 14:20:09 1999
 483 @@ -29,6 +29,7 @@
 484  #if defined(__GLIBC__)
 485  #  include <crypt.h>
 486  #endif
 487 +#include "md5.h"
 488
 489  #define CHECK_DES      1
 490  #define CHECK_MD5      1
 491 @@ -392,7 +393,12 @@ int main(int argc, char **argv)
 492         while(1) {
 493                 if ((p = getpasswd()) == NULL) break;
 494                 if (pwd->pw_passwd[0] == 0 ||
 495 -                   strcmp(crypt(p, pwd->pw_passwd), pwd->pw_passwd) == 0)
 496 +                   strcmp(crypt(p, pwd->pw_passwd), pwd->pw_passwd) == 0
 497 +#ifdef CHECK_MD5
 498 +                   || (strncmp(pwd->pw_passwd, "$1$", 3) == 0 &&
 499 +                       strcmp(Brokencrypt_md5(p, pwd->pw_passwd), pwd->pw_passwd) == 0)
 500 +#endif
 501 +                   )
 502                         sushell(pwd);
 503                 printf("Login incorrect.\n");
 504         }