Drizzled Public API Documentation

CSMd5.cc

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 "CSConfig.h"
00055 #include <string.h>
00056 
00057 #include "CSDefs.h"
00058 #include "CSMd5.h"
00059 #include "CSStrUtil.h"
00060 
00061 #undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */
00062 #ifdef ARCH_IS_BIG_ENDIAN
00063 #  define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
00064 #else
00065 #  define BYTE_ORDER 0
00066 #endif
00067 
00068 
00069 
00070 #define T_MASK ((md5_word_t)~0)
00071 #define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
00072 #define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
00073 #define T3    0x242070db
00074 #define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
00075 #define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
00076 #define T6    0x4787c62a
00077 #define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
00078 #define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
00079 #define T9    0x698098d8
00080 #define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
00081 #define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
00082 #define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
00083 #define T13    0x6b901122
00084 #define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
00085 #define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
00086 #define T16    0x49b40821
00087 #define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
00088 #define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
00089 #define T19    0x265e5a51
00090 #define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
00091 #define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
00092 #define T22    0x02441453
00093 #define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
00094 #define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
00095 #define T25    0x21e1cde6
00096 #define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
00097 #define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
00098 #define T28    0x455a14ed
00099 #define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
00100 #define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
00101 #define T31    0x676f02d9
00102 #define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
00103 #define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
00104 #define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
00105 #define T35    0x6d9d6122
00106 #define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
00107 #define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
00108 #define T38    0x4bdecfa9
00109 #define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
00110 #define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
00111 #define T41    0x289b7ec6
00112 #define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
00113 #define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
00114 #define T44    0x04881d05
00115 #define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
00116 #define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
00117 #define T47    0x1fa27cf8
00118 #define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
00119 #define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
00120 #define T50    0x432aff97
00121 #define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
00122 #define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
00123 #define T53    0x655b59c3
00124 #define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
00125 #define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
00126 #define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
00127 #define T57    0x6fa87e4f
00128 #define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
00129 #define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
00130 #define T60    0x4e0811a1
00131 #define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
00132 #define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
00133 #define T63    0x2ad7d2bb
00134 #define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
00135 
00136 
00137 void CSMd5::md5_process(const u_char *data /*[64]*/)
00138 {
00139     md5_word_t a, b, c, d, t; 
00140 
00141   a = md5_state.abcd[0]; 
00142   b = md5_state.abcd[1];
00143   c = md5_state.abcd[2]; 
00144   d = md5_state.abcd[3];
00145 
00146 #if BYTE_ORDER > 0
00147     /* Define storage only for big-endian CPUs. */
00148     md5_word_t X[16];
00149 #else
00150     /* Define storage for little-endian or both types of CPUs. */
00151     md5_word_t xbuf[16];
00152     const md5_word_t *X;
00153 #endif
00154 
00155     {
00156 #if BYTE_ORDER == 0
00157   /*
00158    * Determine dynamically whether this is a big-endian or
00159    * little-endian machine, since we can use a more efficient
00160    * algorithm on the latter.
00161    */
00162   static const int w = 1;
00163 
00164   if (*((const u_char *)&w)) /* dynamic little-endian */
00165 #endif
00166 #if BYTE_ORDER <= 0   /* little-endian */
00167   {
00168       /*
00169        * On little-endian machines, we can process properly aligned
00170        * data without copying it.
00171        */
00172       if (!((data - (const u_char *)0) & 3)) {
00173     /* data are properly aligned */
00174     X = (const md5_word_t *)data;
00175       } else {
00176     /* not aligned */
00177     memcpy(xbuf, data, 64);
00178     X = xbuf;
00179       }
00180   }
00181 #endif
00182 #if BYTE_ORDER == 0
00183   else      /* dynamic big-endian */
00184 #endif
00185 #if BYTE_ORDER >= 0   /* big-endian */
00186   {
00187       /*
00188        * On big-endian machines, we must arrange the bytes in the
00189        * right order.
00190        */
00191       const u_char *xp = data;
00192       int i;
00193 
00194 #  if BYTE_ORDER == 0
00195       X = xbuf;   /* (dynamic only) */
00196 #  else
00197 #    define xbuf X    /* (static only) */
00198 #  endif
00199       for (i = 0; i < 16; ++i, xp += 4)
00200     xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
00201   }
00202 #endif
00203     }
00204 
00205 
00206 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
00207 
00208     /* Round 1. */
00209     /* Let [abcd k s i] denote the operation
00210        a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
00211 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
00212 #define SET(a, b, c, d, k, s, Ti)\
00213   t = a + F(b,c,d) + X[k] + Ti;\
00214   a = ROTATE_LEFT(t, s) + b
00215     /* Do the following 16 operations. */
00216     SET(a, b, c, d,  0,  7,  T1);
00217     SET(d, a, b, c,  1, 12,  T2);
00218     SET(c, d, a, b,  2, 17,  T3);
00219     SET(b, c, d, a,  3, 22,  T4);
00220     SET(a, b, c, d,  4,  7,  T5);
00221     SET(d, a, b, c,  5, 12,  T6);
00222     SET(c, d, a, b,  6, 17,  T7);
00223     SET(b, c, d, a,  7, 22,  T8);
00224     SET(a, b, c, d,  8,  7,  T9);
00225     SET(d, a, b, c,  9, 12, T10);
00226     SET(c, d, a, b, 10, 17, T11);
00227     SET(b, c, d, a, 11, 22, T12);
00228     SET(a, b, c, d, 12,  7, T13);
00229     SET(d, a, b, c, 13, 12, T14);
00230     SET(c, d, a, b, 14, 17, T15);
00231     SET(b, c, d, a, 15, 22, T16);
00232 #undef SET
00233 
00234      /* Round 2. */
00235      /* Let [abcd k s i] denote the operation
00236           a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
00237 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
00238 #define SET(a, b, c, d, k, s, Ti)\
00239   t = a + G(b,c,d) + X[k] + Ti;\
00240   a = ROTATE_LEFT(t, s) + b
00241      /* Do the following 16 operations. */
00242     SET(a, b, c, d,  1,  5, T17);
00243     SET(d, a, b, c,  6,  9, T18);
00244     SET(c, d, a, b, 11, 14, T19);
00245     SET(b, c, d, a,  0, 20, T20);
00246     SET(a, b, c, d,  5,  5, T21);
00247     SET(d, a, b, c, 10,  9, T22);
00248     SET(c, d, a, b, 15, 14, T23);
00249     SET(b, c, d, a,  4, 20, T24);
00250     SET(a, b, c, d,  9,  5, T25);
00251     SET(d, a, b, c, 14,  9, T26);
00252     SET(c, d, a, b,  3, 14, T27);
00253     SET(b, c, d, a,  8, 20, T28);
00254     SET(a, b, c, d, 13,  5, T29);
00255     SET(d, a, b, c,  2,  9, T30);
00256     SET(c, d, a, b,  7, 14, T31);
00257     SET(b, c, d, a, 12, 20, T32);
00258 #undef SET
00259 
00260      /* Round 3. */
00261      /* Let [abcd k s t] denote the operation
00262           a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
00263 #define H(x, y, z) ((x) ^ (y) ^ (z))
00264 #define SET(a, b, c, d, k, s, Ti)\
00265   t = a + H(b,c,d) + X[k] + Ti;\
00266   a = ROTATE_LEFT(t, s) + b
00267      /* Do the following 16 operations. */
00268     SET(a, b, c, d,  5,  4, T33);
00269     SET(d, a, b, c,  8, 11, T34);
00270     SET(c, d, a, b, 11, 16, T35);
00271     SET(b, c, d, a, 14, 23, T36);
00272     SET(a, b, c, d,  1,  4, T37);
00273     SET(d, a, b, c,  4, 11, T38);
00274     SET(c, d, a, b,  7, 16, T39);
00275     SET(b, c, d, a, 10, 23, T40);
00276     SET(a, b, c, d, 13,  4, T41);
00277     SET(d, a, b, c,  0, 11, T42);
00278     SET(c, d, a, b,  3, 16, T43);
00279     SET(b, c, d, a,  6, 23, T44);
00280     SET(a, b, c, d,  9,  4, T45);
00281     SET(d, a, b, c, 12, 11, T46);
00282     SET(c, d, a, b, 15, 16, T47);
00283     SET(b, c, d, a,  2, 23, T48);
00284 #undef SET
00285 
00286      /* Round 4. */
00287      /* Let [abcd k s t] denote the operation
00288           a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
00289 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
00290 #define SET(a, b, c, d, k, s, Ti)\
00291   t = a + I(b,c,d) + X[k] + Ti;\
00292   a = ROTATE_LEFT(t, s) + b
00293      /* Do the following 16 operations. */
00294     SET(a, b, c, d,  0,  6, T49);
00295     SET(d, a, b, c,  7, 10, T50);
00296     SET(c, d, a, b, 14, 15, T51);
00297     SET(b, c, d, a,  5, 21, T52);
00298     SET(a, b, c, d, 12,  6, T53);
00299     SET(d, a, b, c,  3, 10, T54);
00300     SET(c, d, a, b, 10, 15, T55);
00301     SET(b, c, d, a,  1, 21, T56);
00302     SET(a, b, c, d,  8,  6, T57);
00303     SET(d, a, b, c, 15, 10, T58);
00304     SET(c, d, a, b,  6, 15, T59);
00305     SET(b, c, d, a, 13, 21, T60);
00306     SET(a, b, c, d,  4,  6, T61);
00307     SET(d, a, b, c, 11, 10, T62);
00308     SET(c, d, a, b,  2, 15, T63);
00309     SET(b, c, d, a,  9, 21, T64);
00310 #undef SET
00311 
00312      /* Then perform the following additions. (That is increment each
00313         of the four registers by the value it had before this block
00314         was started.) */
00315     md5_state.abcd[0] += a;
00316     md5_state.abcd[1] += b;
00317     md5_state.abcd[2] += c;
00318     md5_state.abcd[3] += d;
00319 }
00320 
00321 void
00322 CSMd5::md5_init()
00323 {
00324   /* Indicates that there is no digest: */
00325   digest_cstr[0] = 0;
00326 
00327     md5_state.count[0] = md5_state.count[1] = 0;
00328     md5_state.abcd[0] = 0x67452301;
00329     md5_state.abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
00330     md5_state.abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
00331     md5_state.abcd[3] = 0x10325476;
00332 }
00333 
00334 void CSMd5::md5_append(const u_char *data, int nbytes)
00335 {
00336     const u_char *p = data;
00337   int left = nbytes;
00338     int offset = (md5_state.count[0] >> 3) & 63;
00339     md5_word_t nbits = (md5_word_t)(nbytes << 3);
00340 
00341    if (nbytes <= 0) {
00342     return;
00343   }
00344   
00345    /* Update the message length. */
00346     md5_state.count[1] += nbytes >> 29;
00347     md5_state.count[0] += nbits;
00348     if (md5_state.count[0] < nbits)
00349     md5_state.count[1]++;
00350 
00351     /* Process an initial partial block. */
00352     if (offset) {
00353     int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
00354 
00355     memcpy(md5_state.buf + offset, p, copy);
00356     if (offset + copy < 64)
00357       return;
00358     p += copy;
00359     left -= copy;
00360     md5_process(md5_state.buf);
00361     }
00362 
00363     /* Process full blocks. */
00364     for (; left >= 64; p += 64, left -= 64)
00365     md5_process(p);
00366 
00367     /* Process a final partial block. */
00368     if (left)
00369     memcpy(md5_state.buf, p, left);
00370 }
00371 
00372 
00373 void CSMd5::md5_digest()
00374 {
00375     static const u_char pad[64] = {
00376   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00377   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00378   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00379   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
00380     };
00381     u_char data[8];
00382     int i;
00383 
00384     /* Save the length before padding. */
00385     for (i = 0; i < 8; ++i)
00386     data[i] = (u_char)(md5_state.count[i >> 2] >> ((i & 3) << 3));
00387     /* Pad to 56 bytes mod 64. */
00388     md5_append(pad, ((55 - (md5_state.count[0] >> 3)) & 63) + 1);
00389     /* Append the length. */
00390     md5_append(data, 8);
00391     for (i = 0; i < 16; ++i)
00392     digest[i] = (u_char)(md5_state.abcd[i >> 2] >> ((i & 3) << 3));
00393 
00394   /* Generate the text version: */
00395   cs_bin_to_hex(MD5_CHECKSUM_STRING_SIZE, digest_cstr, MD5_CHECKSUM_SIZE, digest);
00396 }