cde/programs/dtcm/dtcm/md5.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these libraries and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 static char sccsid[] = "$XConsortium: md5.c /main/2 1996/03/25 10:28:16 rswiston $";
  24 /*
  25  *   COMPONENT_NAME: desktop
  26  *
  27  *   FUNCTIONS: Decode
  28  *              Encode
  29  *              F
  30  *              FF
  31  *              G
  32  *              GG
  33  *              H
  34  *              HH
  35  *              I
  36  *              II
  37  *              MD5Final
  38  *              MD5Init
  39  *              MD5Transform
  40  *              MD5Update
  41  *              MD5_memcpy
  42  *              MD5_memset
  43  *              ROTATE_LEFT
  44  *
  45  *   ORIGINS: 119
  46  *
  47  */
  48 /*
  49  *+SNOTICE
  50  *
  51  *
  52  *      $Revision: /main/2 $
  53  *
  54  *      RESTRICTED CONFIDENTIAL INFORMATION:
  55  *
  56  *      The information in this document is subject to special
  57  *      restrictions in a confidential disclosure agreement bertween
  58  *      HP, IBM, Sun, USL, SCO and Univel.  Do not distribute this
  59  *      document outside HP, IBM, Sun, USL, SCO, or Univel wihtout
  60  *      Sun's specific written approval.  This documment and all copies
  61  *      and derivative works thereof must be returned or destroyed at
  62  *      Sun's request.
  63  *
  64  *      Copyright 1993 Sun Microsystems, Inc.  All rights reserved.
  65  *
  66  *+ENOTICE
  67  */
  68
  69 #ifndef I_HAVE_NO_IDENT
  70 #endif
  71
  72 /* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
  73  */
  74
  75 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
  76    rights reserved.
  77
  78    License to copy and use this software is granted provided that it
  79    is identified as the "RSA Data Security, Inc. MD5 Message-Digest
  80    Algorithm" in all material mentioning or referencing this software
  81    or this function.
  82
  83    License is also granted to make and use derivative works provided
  84    that such works are identified as "derived from the RSA Data
  85    Security, Inc. MD5 Message-Digest Algorithm" in all material
  86    mentioning or referencing the derived work.
  87
  88    RSA Data Security, Inc. makes no representations concerning either
  89    the merchantability of this software or the suitability of this
  90    software for any particular purpose. It is provided "as is"
  91    without express or implied warranty of any kind.
  92
  93    These notices must be retained in any copies of any part of this
  94    documentation and/or software.
  95    */
  96
  97 #include <string.h>
  98 #include "md5.h"
  99
 100 /* Constants for MD5Transform routine.
 101  */
 102
 103 #define S11 7
 104 #define S12 12
 105 #define S13 17
 106 #define S14 22
 107 #define S21 5
 108 #define S22 9
 109 #define S23 14
 110 #define S24 20
 111 #define S31 4
 112 #define S32 11
 113 #define S33 16
 114 #define S34 23
 115 #define S41 6
 116 #define S42 10
 117 #define S43 15
 118 #define S44 21
 119
 120 static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64]));
 121 static void Encode PROTO_LIST
 122 ((unsigned char *, UINT4 *, unsigned int));
 123 static void Decode PROTO_LIST
 124 ((UINT4 *, unsigned char *, unsigned int));
 125 static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int));
 126 static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int));
 127
 128 static unsigned char PADDING[64] = {
 129     0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 130     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 131     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 132 };
 133
 134 /* F, G, H and I are basic MD5 functions.
 135  */
 136 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
 137 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
 138 #define H(x, y, z) ((x) ^ (y) ^ (z))
 139 #define I(x, y, z) ((y) ^ ((x) | (~z)))
 140
 141 /* ROTATE_LEFT rotates x left n bits.
 142  */
 143 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
 144
 145 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
 146    Rotation is separate from addition to prevent recomputation.
 147    */
 148 #define FF(a, b, c, d, x, s, ac) { \
 149 (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
 150 (a) = ROTATE_LEFT ((a), (s)); \
 151 (a) += (b); \
 152 }
 153 #define GG(a, b, c, d, x, s, ac) { \
 154 (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
 155 (a) = ROTATE_LEFT ((a), (s)); \
 156 (a) += (b); \
 157 }
 158 #define HH(a, b, c, d, x, s, ac) { \
 159 (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
 160 (a) = ROTATE_LEFT ((a), (s)); \
 161 (a) += (b); \
 162 }
 163 #define II(a, b, c, d, x, s, ac) { \
 164 (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
 165 (a) = ROTATE_LEFT ((a), (s)); \
 166 (a) += (b); \
 167 }
 168
 169 /* MD5 initialization. Begins an MD5 operation, writing a new context.
 170  */
 171 void MD5Init (MD5_CTX *context)
 172 {
 173     context->count[0] = context->count[1] = 0;
 174     /* Load magic initialization constants.
 175      */
 176     context->state[0] = 0x67452301;
 177     context->state[1] = 0xefcdab89;
 178     context->state[2] = 0x98badcfe;
 179     context->state[3] = 0x10325476;
 180 }
 181
 182 /* MD5 block update operation. Continues an MD5 message-digest
 183    operation, processing another message block, and updating the
 184    context.
 185
 186    context, context
 187    input, input block
 188    inputLen, length of input block
 189    */
 190 void MD5Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen)
 191 {
 192     unsigned int i, index, partLen;
 193
 194     /* Compute number of bytes mod 64 */
 195     index = (unsigned int)((context->count[0] >> 3) & 0x3F);
 196
 197     /* Update number of bits */
 198     if ((context->count[0] += ((UINT4)inputLen << 3))
 199         < ((UINT4)inputLen << 3))
 200         context->count[1]++;
 201     context->count[1] += ((UINT4)inputLen >> 29);
 202
 203     partLen = 64 - index;
 204
 205     /* Transform as many times as possible.
 206      */
 207     if (inputLen >= partLen) {
 208         MD5_memcpy
 209             ((POINTER)&context->buffer[index], (POINTER)input, partLen);
 210         MD5Transform (context->state, context->buffer);
 211
 212         for (i = partLen; i + 63 < inputLen; i += 64)
 213             MD5Transform (context->state, &input[i]);
 214
 215         index = 0;
 216     }
 217     else
 218         i = 0;
 219
 220     /* Buffer remaining input */
 221     MD5_memcpy
 222         ((POINTER)&context->buffer[index], (POINTER)&input[i],
 223          inputLen-i);
 224 }
 225
 226 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
 227    the message digest and zeroizing the context.
 228
 229    digest, message digest
 230    context, context
 231    */
 232 void MD5Final (unsigned char digest[16], MD5_CTX *context)
 233 {
 234     unsigned char bits[8];
 235     unsigned int index, padLen;
 236
 237     /* Save number of bits */
 238     Encode (bits, context->count, 8);
 239
 240     /* Pad out to 56 mod 64.
 241      */
 242     index = (unsigned int)((context->count[0] >> 3) & 0x3f);
 243     padLen = (index < 56) ? (56 - index) : (120 - index);
 244     MD5Update (context, PADDING, padLen);
 245
 246     /* Append length (before padding) */
 247     MD5Update (context, bits, 8);
 248
 249     /* Store state in digest */
 250     Encode (digest, context->state, 16);
 251
 252     /* Zeroize sensitive information.
 253      */
 254     MD5_memset ((POINTER)context, 0, sizeof (*context));
 255 }
 256
 257 /* MD5 basic transformation. Transforms state based on block.
 258  */
 259 static void MD5Transform (UINT4 state[4], unsigned char block[64])
 260 {
 261     UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
 262
 263     Decode (x, block, 64);
 264
 265     /* Round 1 */
 266     FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
 267     FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
 268     FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
 269     FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
 270     FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
 271     FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
 272     FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
 273     FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
 274     FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
 275     FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
 276     FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
 277     FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
 278     FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
 279     FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
 280     FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
 281     FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 282
 283     /* Round 2 */
 284     GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
 285     GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
 286     GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
 287     GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
 288     GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
 289     GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
 290     GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
 291     GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
 292     GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
 293     GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
 294     GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
 295     GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
 296     GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
 297     GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
 298     GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
 299     GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
 300
 301     /* Round 3 */
 302     HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
 303     HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
 304     HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
 305     HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
 306     HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
 307     HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
 308     HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
 309     HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
 310     HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
 311     HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
 312     HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
 313     HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
 314     HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
 315     HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
 316     HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
 317     HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
 318
 319     /* Round 4 */
 320     II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
 321     II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
 322     II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
 323     II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
 324     II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
 325     II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
 326     II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
 327     II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
 328     II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
 329     II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
 330     II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
 331     II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
 332     II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
 333     II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
 334     II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
 335     II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
 336
 337     state[0] += a;
 338     state[1] += b;
 339     state[2] += c;
 340     state[3] += d;
 341
 342     /* Zeroize sensitive information.
 343      */
 344     MD5_memset ((POINTER)x, 0, sizeof (x));
 345 }
 346
 347 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
 348    a multiple of 4.
 349    */
 350 static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
 351 {
 352     unsigned int i, j;
 353
 354     for (i = 0, j = 0; j < len; i++, j += 4) {
 355         output[j] = (unsigned char)(input[i] & 0xff);
 356         output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
 357         output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
 358         output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
 359     }
 360 }
 361
 362 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
 363    a multiple of 4.
 364    */
 365 static void Decode (UINT4 *output, unsigned char *input, unsigned int len)
 366 {
 367     unsigned int i, j;
 368
 369     for (i = 0, j = 0; j < len; i++, j += 4)
 370         output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
 371             (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
 372 }
 373
 374 /* Note: Replace "for loop" with standard memcpy if possible.
 375  */
 376
 377 static void MD5_memcpy (POINTER output, POINTER input, unsigned int len)
 378 {
 379     memcpy(output, input, len);
 380 }
 381
 382 /* Note: Replace "for loop" with standard memset if possible.
 383  */
 384 static void MD5_memset (POINTER output, int value, unsigned int len)
 385 {
 386     memset(output, value, len);
 387 }