secure.cc

   1
   2 #include "secure.h"
   3
   4 /*****************************************************************/
   5
   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 typedef unsigned long word32;
  24 typedef unsigned char byte;
  25
  26 struct xMD5Context {
  27         word32 buf[4];
  28         word32 bytes[2];
  29         word32 in[16];
  30 };
  31
  32 void xMD5Init(struct xMD5Context *context);
  33 void xMD5Update(struct xMD5Context *context, byte const *buf, int len);
  34 void xMD5Final(byte digest[16], struct xMD5Context *context);
  35 void xMD5Transform(word32 buf[4], word32 const in[16]);
  36
  37
  38 /*
  39  * Shuffle the bytes into little-endian order within words, as per the
  40  * MD5 spec.  Note: this code works regardless of the byte order.
  41  */
  42 void
  43 byteSwap(word32 *buf, unsigned words)
  44 {
  45         byte *p = (byte *)buf;
  46
  47         do {
  48                 *buf++ = (word32)((unsigned)p[3] << 8 | p[2]) << 16 |
  49                         ((unsigned)p[1] << 8 | p[0]);
  50                 p += 4;
  51         } while (--words);
  52 }
  53
  54 /*
  55  * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
  56  * initialization constants.
  57  */
  58 void
  59 xMD5Init(struct xMD5Context *ctx)
  60 {
  61         ctx->buf[0] = 0x67452301;
  62         ctx->buf[1] = 0xefcdab89;
  63         ctx->buf[2] = 0x98badcfe;
  64         ctx->buf[3] = 0x10325476;
  65
  66         ctx->bytes[0] = 0;
  67         ctx->bytes[1] = 0;
  68 }
  69
  70 /*
  71  * Update context to reflect the concatenation of another buffer full
  72  * of bytes.
  73  */
  74 void
  75 xMD5Update(struct xMD5Context *ctx, byte const *buf, int len)
  76 {
  77         word32 t;
  78
  79         /* Update byte count */
  80
  81         t = ctx->bytes[0];
  82         if ((ctx->bytes[0] = t + len) < t)
  83                 ctx->bytes[1]++;        /* Carry from low to high */
  84
  85         t = 64 - (t & 0x3f);    /* Space available in ctx->in (at least 1) */
  86         if ((unsigned)t > len) {
  87                 bcopy(buf, (byte *)ctx->in + 64 - (unsigned)t, len);
  88                 return;
  89         }
  90         /* First chunk is an odd size */
  91         bcopy(buf,(byte *)ctx->in + 64 - (unsigned)t, (unsigned)t);
  92         byteSwap(ctx->in, 16);
  93         xMD5Transform(ctx->buf, ctx->in);
  94         buf += (unsigned)t;
  95         len -= (unsigned)t;
  96
  97         /* Process data in 64-byte chunks */
  98         while (len >= 64) {
  99                 bcopy(buf, ctx->in, 64);
 100                 byteSwap(ctx->in, 16);
 101                 xMD5Transform(ctx->buf, ctx->in);
 102                 buf += 64;
 103                 len -= 64;
 104         }
 105
 106         /* Handle any remaining bytes of data. */
 107         bcopy(buf, ctx->in, len);
 108 }
 109
 110 /*
 111  * Final wrapup - pad to 64-byte boundary with the bit pattern
 112  * 1 0* (64-bit count of bits processed, MSB-first)
 113  */
 114 void
 115 xMD5Final(byte digest[16], struct xMD5Context *ctx)
 116 {
 117         int count = (int)(ctx->bytes[0] & 0x3f); /* Bytes in ctx->in */
 118         byte *p = (byte *)ctx->in + count;      /* First unused byte */
 119
 120         /* Set the first char of padding to 0x80.  There is always room. */
 121         *p++ = 0x80;
 122
 123         /* Bytes of padding needed to make 56 bytes (-8..55) */
 124         count = 56 - 1 - count;
 125
 126         if (count < 0) {        /* Padding forces an extra block */
 127                 bzero(p, count+8);
 128                 byteSwap(ctx->in, 16);
 129                 xMD5Transform(ctx->buf, ctx->in);
 130                 p = (byte *)ctx->in;
 131                 count = 56;
 132         }
 133         bzero(p, count+8);
 134         byteSwap(ctx->in, 14);
 135
 136         /* Append length in bits and transform */
 137         ctx->in[14] = ctx->bytes[0] << 3;
 138         ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
 139         xMD5Transform(ctx->buf, ctx->in);
 140
 141         byteSwap(ctx->buf, 4);
 142         bcopy(ctx->buf, digest, 16);
 143         bzero(ctx,sizeof(ctx));
 144 }
 145
 146
 147 /* The four core functions - F1 is optimized somewhat */
 148
 149 /* #define F1(x, y, z) (x & y | ~x & z) */
 150 #define F1(x, y, z) (z ^ (x & (y ^ z)))
 151 #define F2(x, y, z) F1(z, x, y)
 152 #define F3(x, y, z) (x ^ y ^ z)
 153 #define F4(x, y, z) (y ^ (x | ~z))
 154
 155 /* This is the central step in the MD5 algorithm. */
 156 #define MD5STEP(f,w,x,y,z,in,s) \
 157          (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
 158
 159 /*
 160  * The core of the MD5 algorithm, this alters an existing MD5 hash to
 161  * reflect the addition of 16 longwords of new data.  MD5Update blocks
 162  * the data and converts bytes into longwords for this routine.
 163  */
 164 void
 165 xMD5Transform(word32 buf[4], word32 const in[16])
 166 {
 167         register word32 a, b, c, d;
 168
 169         a = buf[0];
 170         b = buf[1];
 171         c = buf[2];
 172         d = buf[3];
 173
 174         MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
 175         MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
 176         MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
 177         MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
 178         MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
 179         MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
 180         MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
 181         MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
 182         MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
 183         MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
 184         MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
 185         MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
 186         MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
 187         MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
 188         MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
 189         MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
 190
 191         MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
 192         MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
 193         MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
 194         MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
 195         MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
 196         MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
 197         MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
 198         MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
 199         MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
 200         MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
 201         MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
 202         MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
 203         MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
 204         MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
 205         MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
 206         MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
 207
 208         MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
 209         MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
 210         MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
 211         MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
 212         MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
 213         MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
 214         MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
 215         MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
 216         MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
 217         MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
 218         MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
 219         MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
 220         MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
 221         MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
 222         MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
 223         MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
 224
 225         MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
 226         MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
 227         MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
 228         MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
 229         MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
 230         MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
 231         MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
 232         MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
 233         MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
 234         MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
 235         MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
 236         MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
 237         MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
 238         MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
 239         MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
 240         MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
 241
 242         buf[0] += a;
 243         buf[1] += b;
 244         buf[2] += c;
 245         buf[3] += d;
 246 }
 247
 248
 249 void MD5(void *dest, void *orig, int len)
 250 {
 251         struct xMD5Context context;
 252
 253         xMD5Init(&context);
 254         xMD5Update(&context, orig, len);
 255         xMD5Final(dest, &context);
 256 }
 257
 258 void secure_nick(char *result, char *user, char *host, char *key, int time)
 259 {
 260   int k;
 261   char *s, *t;
 262   char *code = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 263   char src[SECURE_BUFFER_SIZE], dst[16];
 264
 265   sprintf(src, "%s%s%s%d", user, host, key, time);
 266   MD5(dst, src, strlen(src));
 267
 268   s = dst; t = result;
 269   for(k=0; k<NICK_LENGTH; k++) *t++ = code[((unsigned int) *s++)%52];
 270   *t = '\0';
 271
 272   cout<<"RESULT=>"<<result
 273       <<"< USER=>"<<user
 274       <<"< HOST=>"<<host
 275       <<"< KEY=>"<<key
 276       <<"< time="<<time<<"\n";
 277
 278 };