Back to index

tetex-bin  3.0
md5.c
Go to the documentation of this file.
00001 /*
00002   Copyright (C) 1999, 2000, 2002 Aladdin Enterprises.  All rights reserved.
00003 
00004   This software is provided 'as-is', without any express or implied
00005   warranty.  In no event will the authors be held liable for any damages
00006   arising from the use of this software.
00007 
00008   Permission is granted to anyone to use this software for any purpose,
00009   including commercial applications, and to alter it and redistribute it
00010   freely, subject to the following restrictions:
00011 
00012   1. The origin of this software must not be misrepresented; you must not
00013      claim that you wrote the original software. If you use this software
00014      in a product, an acknowledgment in the product documentation would be
00015      appreciated but is not required.
00016   2. Altered source versions must be plainly marked as such, and must not be
00017      misrepresented as being the original software.
00018   3. This notice may not be removed or altered from any source distribution.
00019 
00020   L. Peter Deutsch
00021   ghost@aladdin.com
00022 
00023  */
00024 /* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */
00025 /*
00026   Independent implementation of MD5 (RFC 1321).
00027 
00028   This code implements the MD5 Algorithm defined in RFC 1321, whose
00029   text is available at
00030        http://www.ietf.org/rfc/rfc1321.txt
00031   The code is derived from the text of the RFC, including the test suite
00032   (section A.5) but excluding the rest of Appendix A.  It does not include
00033   any code or documentation that is identified in the RFC as being
00034   copyrighted.
00035 
00036   The original and principal author of md5.c is L. Peter Deutsch
00037   <ghost@aladdin.com>.  Other authors are noted in the change history
00038   that follows (in reverse chronological order):
00039 
00040   2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
00041        either statically or dynamically; added missing #include <string.h>
00042        in library.
00043   2002-03-11 lpd Corrected argument list for main(), and added int return
00044        type, in test program and T value program.
00045   2002-02-21 lpd Added missing #include <stdio.h> in test program.
00046   2000-07-03 lpd Patched to eliminate warnings about "constant is
00047        unsigned in ANSI C, signed in traditional"; made test program
00048        self-checking.
00049   1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
00050   1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
00051   1999-05-03 lpd Original version.
00052  */
00053 
00054 #include "md5.h"
00055 #include <string.h>
00056 
00057 #undef BYTE_ORDER    /* 1 = big-endian, -1 = little-endian, 0 = unknown */
00058 #ifdef ARCH_IS_BIG_ENDIAN
00059 #  define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
00060 #else
00061 #  define BYTE_ORDER 0
00062 #endif
00063 
00064 #define T_MASK ((md5_word_t)~0)
00065 #define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
00066 #define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
00067 #define T3    0x242070db
00068 #define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
00069 #define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
00070 #define T6    0x4787c62a
00071 #define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
00072 #define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
00073 #define T9    0x698098d8
00074 #define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
00075 #define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
00076 #define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
00077 #define T13    0x6b901122
00078 #define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
00079 #define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
00080 #define T16    0x49b40821
00081 #define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
00082 #define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
00083 #define T19    0x265e5a51
00084 #define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
00085 #define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
00086 #define T22    0x02441453
00087 #define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
00088 #define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
00089 #define T25    0x21e1cde6
00090 #define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
00091 #define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
00092 #define T28    0x455a14ed
00093 #define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
00094 #define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
00095 #define T31    0x676f02d9
00096 #define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
00097 #define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
00098 #define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
00099 #define T35    0x6d9d6122
00100 #define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
00101 #define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
00102 #define T38    0x4bdecfa9
00103 #define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
00104 #define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
00105 #define T41    0x289b7ec6
00106 #define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
00107 #define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
00108 #define T44    0x04881d05
00109 #define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
00110 #define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
00111 #define T47    0x1fa27cf8
00112 #define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
00113 #define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
00114 #define T50    0x432aff97
00115 #define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
00116 #define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
00117 #define T53    0x655b59c3
00118 #define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
00119 #define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
00120 #define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
00121 #define T57    0x6fa87e4f
00122 #define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
00123 #define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
00124 #define T60    0x4e0811a1
00125 #define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
00126 #define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
00127 #define T63    0x2ad7d2bb
00128 #define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
00129 
00130 
00131 static void
00132 md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
00133 {
00134     md5_word_t
00135        a = pms->abcd[0], b = pms->abcd[1],
00136        c = pms->abcd[2], d = pms->abcd[3];
00137     md5_word_t t;
00138 #if BYTE_ORDER > 0
00139     /* Define storage only for big-endian CPUs. */
00140     md5_word_t X[16];
00141 #else
00142     /* Define storage for little-endian or both types of CPUs. */
00143     md5_word_t xbuf[16];
00144     const md5_word_t *X;
00145 #endif
00146 
00147     {
00148 #if BYTE_ORDER == 0
00149        /*
00150         * Determine dynamically whether this is a big-endian or
00151         * little-endian machine, since we can use a more efficient
00152         * algorithm on the latter.
00153         */
00154        static const int w = 1;
00155 
00156        if (*((const md5_byte_t *)&w)) /* dynamic little-endian */
00157 #endif
00158 #if BYTE_ORDER <= 0         /* little-endian */
00159        {
00160            /*
00161             * On little-endian machines, we can process properly aligned
00162             * data without copying it.
00163             */
00164            if (!((data - (const md5_byte_t *)0) & 3)) {
00165               /* data are properly aligned */
00166               X = (const md5_word_t *)data;
00167            } else {
00168               /* not aligned */
00169               memcpy(xbuf, data, 64);
00170               X = xbuf;
00171            }
00172        }
00173 #endif
00174 #if BYTE_ORDER == 0
00175        else                 /* dynamic big-endian */
00176 #endif
00177 #if BYTE_ORDER >= 0         /* big-endian */
00178        {
00179            /*
00180             * On big-endian machines, we must arrange the bytes in the
00181             * right order.
00182             */
00183            const md5_byte_t *xp = data;
00184            int i;
00185 
00186 #  if BYTE_ORDER == 0
00187            X = xbuf;        /* (dynamic only) */
00188 #  else
00189 #    define xbuf X          /* (static only) */
00190 #  endif
00191            for (i = 0; i < 16; ++i, xp += 4)
00192               xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
00193        }
00194 #endif
00195     }
00196 
00197 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
00198 
00199     /* Round 1. */
00200     /* Let [abcd k s i] denote the operation
00201        a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
00202 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
00203 #define SET(a, b, c, d, k, s, Ti)\
00204   t = a + F(b,c,d) + X[k] + Ti;\
00205   a = ROTATE_LEFT(t, s) + b
00206     /* Do the following 16 operations. */
00207     SET(a, b, c, d,  0,  7,  T1);
00208     SET(d, a, b, c,  1, 12,  T2);
00209     SET(c, d, a, b,  2, 17,  T3);
00210     SET(b, c, d, a,  3, 22,  T4);
00211     SET(a, b, c, d,  4,  7,  T5);
00212     SET(d, a, b, c,  5, 12,  T6);
00213     SET(c, d, a, b,  6, 17,  T7);
00214     SET(b, c, d, a,  7, 22,  T8);
00215     SET(a, b, c, d,  8,  7,  T9);
00216     SET(d, a, b, c,  9, 12, T10);
00217     SET(c, d, a, b, 10, 17, T11);
00218     SET(b, c, d, a, 11, 22, T12);
00219     SET(a, b, c, d, 12,  7, T13);
00220     SET(d, a, b, c, 13, 12, T14);
00221     SET(c, d, a, b, 14, 17, T15);
00222     SET(b, c, d, a, 15, 22, T16);
00223 #undef SET
00224 
00225      /* Round 2. */
00226      /* Let [abcd k s i] denote the operation
00227           a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
00228 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
00229 #define SET(a, b, c, d, k, s, Ti)\
00230   t = a + G(b,c,d) + X[k] + Ti;\
00231   a = ROTATE_LEFT(t, s) + b
00232      /* Do the following 16 operations. */
00233     SET(a, b, c, d,  1,  5, T17);
00234     SET(d, a, b, c,  6,  9, T18);
00235     SET(c, d, a, b, 11, 14, T19);
00236     SET(b, c, d, a,  0, 20, T20);
00237     SET(a, b, c, d,  5,  5, T21);
00238     SET(d, a, b, c, 10,  9, T22);
00239     SET(c, d, a, b, 15, 14, T23);
00240     SET(b, c, d, a,  4, 20, T24);
00241     SET(a, b, c, d,  9,  5, T25);
00242     SET(d, a, b, c, 14,  9, T26);
00243     SET(c, d, a, b,  3, 14, T27);
00244     SET(b, c, d, a,  8, 20, T28);
00245     SET(a, b, c, d, 13,  5, T29);
00246     SET(d, a, b, c,  2,  9, T30);
00247     SET(c, d, a, b,  7, 14, T31);
00248     SET(b, c, d, a, 12, 20, T32);
00249 #undef SET
00250 
00251      /* Round 3. */
00252      /* Let [abcd k s t] denote the operation
00253           a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
00254 #define H(x, y, z) ((x) ^ (y) ^ (z))
00255 #define SET(a, b, c, d, k, s, Ti)\
00256   t = a + H(b,c,d) + X[k] + Ti;\
00257   a = ROTATE_LEFT(t, s) + b
00258      /* Do the following 16 operations. */
00259     SET(a, b, c, d,  5,  4, T33);
00260     SET(d, a, b, c,  8, 11, T34);
00261     SET(c, d, a, b, 11, 16, T35);
00262     SET(b, c, d, a, 14, 23, T36);
00263     SET(a, b, c, d,  1,  4, T37);
00264     SET(d, a, b, c,  4, 11, T38);
00265     SET(c, d, a, b,  7, 16, T39);
00266     SET(b, c, d, a, 10, 23, T40);
00267     SET(a, b, c, d, 13,  4, T41);
00268     SET(d, a, b, c,  0, 11, T42);
00269     SET(c, d, a, b,  3, 16, T43);
00270     SET(b, c, d, a,  6, 23, T44);
00271     SET(a, b, c, d,  9,  4, T45);
00272     SET(d, a, b, c, 12, 11, T46);
00273     SET(c, d, a, b, 15, 16, T47);
00274     SET(b, c, d, a,  2, 23, T48);
00275 #undef SET
00276 
00277      /* Round 4. */
00278      /* Let [abcd k s t] denote the operation
00279           a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
00280 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
00281 #define SET(a, b, c, d, k, s, Ti)\
00282   t = a + I(b,c,d) + X[k] + Ti;\
00283   a = ROTATE_LEFT(t, s) + b
00284      /* Do the following 16 operations. */
00285     SET(a, b, c, d,  0,  6, T49);
00286     SET(d, a, b, c,  7, 10, T50);
00287     SET(c, d, a, b, 14, 15, T51);
00288     SET(b, c, d, a,  5, 21, T52);
00289     SET(a, b, c, d, 12,  6, T53);
00290     SET(d, a, b, c,  3, 10, T54);
00291     SET(c, d, a, b, 10, 15, T55);
00292     SET(b, c, d, a,  1, 21, T56);
00293     SET(a, b, c, d,  8,  6, T57);
00294     SET(d, a, b, c, 15, 10, T58);
00295     SET(c, d, a, b,  6, 15, T59);
00296     SET(b, c, d, a, 13, 21, T60);
00297     SET(a, b, c, d,  4,  6, T61);
00298     SET(d, a, b, c, 11, 10, T62);
00299     SET(c, d, a, b,  2, 15, T63);
00300     SET(b, c, d, a,  9, 21, T64);
00301 #undef SET
00302 
00303      /* Then perform the following additions. (That is increment each
00304         of the four registers by the value it had before this block
00305         was started.) */
00306     pms->abcd[0] += a;
00307     pms->abcd[1] += b;
00308     pms->abcd[2] += c;
00309     pms->abcd[3] += d;
00310 }
00311 
00312 void
00313 md5_init(md5_state_t *pms)
00314 {
00315     pms->count[0] = pms->count[1] = 0;
00316     pms->abcd[0] = 0x67452301;
00317     pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
00318     pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
00319     pms->abcd[3] = 0x10325476;
00320 }
00321 
00322 void
00323 md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
00324 {
00325     const md5_byte_t *p = data;
00326     int left = nbytes;
00327     int offset = (pms->count[0] >> 3) & 63;
00328     md5_word_t nbits = (md5_word_t)(nbytes << 3);
00329 
00330     if (nbytes <= 0)
00331        return;
00332 
00333     /* Update the message length. */
00334     pms->count[1] += nbytes >> 29;
00335     pms->count[0] += nbits;
00336     if (pms->count[0] < nbits)
00337        pms->count[1]++;
00338 
00339     /* Process an initial partial block. */
00340     if (offset) {
00341        int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
00342 
00343        memcpy(pms->buf + offset, p, copy);
00344        if (offset + copy < 64)
00345            return;
00346        p += copy;
00347        left -= copy;
00348        md5_process(pms, pms->buf);
00349     }
00350 
00351     /* Process full blocks. */
00352     for (; left >= 64; p += 64, left -= 64)
00353        md5_process(pms, p);
00354 
00355     /* Process a final partial block. */
00356     if (left)
00357        memcpy(pms->buf, p, left);
00358 }
00359 
00360 void
00361 md5_finish(md5_state_t *pms, md5_byte_t digest[16])
00362 {
00363     static const md5_byte_t pad[64] = {
00364        0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00365        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00366        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00367        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
00368     };
00369     md5_byte_t data[8];
00370     int i;
00371 
00372     /* Save the length before padding. */
00373     for (i = 0; i < 8; ++i)
00374        data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
00375     /* Pad to 56 bytes mod 64. */
00376     md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
00377     /* Append the length. */
00378     md5_append(pms, data, 8);
00379     for (i = 0; i < 16; ++i)
00380        digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
00381 }