0

1 
// MD5 code originally from http://sourceforge.net/projects/libmd5rfc/


2 
// License: zlib.


3 
// I cleaned it up a little for MojoSetup's specific purposes. ryan.


4 


5 
/*


6 
Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved.


7 


8 
This software is provided 'asis', without any express or implied


9 
warranty. In no event will the authors be held liable for any damages


10 
arising from the use of this software.


11 


12 
Permission is granted to anyone to use this software for any purpose,


13 
including commercial applications, and to alter it and redistribute it


14 
freely, subject to the following restrictions:


15 


16 
1. The origin of this software must not be misrepresented; you must not


17 
claim that you wrote the original software. If you use this software


18 
in a product, an acknowledgment in the product documentation would be


19 
appreciated but is not required.


20 
2. Altered source versions must be plainly marked as such, and must not be


21 
misrepresented as being the original software.


22 
3. This notice may not be removed or altered from any source distribution.


23 


24 
L. Peter Deutsch


25 
ghost@aladdin.com


26 


27 
*/


28 
/* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */


29 
/*


30 
Independent implementation of MD5 (RFC 1321).


31 


32 
This code implements the MD5 Algorithm defined in RFC 1321, whose


33 
text is available at


34 
http://www.ietf.org/rfc/rfc1321.txt


35 
The code is derived from the text of the RFC, including the test suite


36 
(section A.5) but excluding the rest of Appendix A. It does not include


37 
any code or documentation that is identified in the RFC as being


38 
copyrighted.


39 


40 
The original and principal author of md5.c is L. Peter Deutsch


41 
<ghost@aladdin.com>. Other authors are noted in the change history


42 
that follows (in reverse chronological order):


43 


44 
20020413 lpd Clarified derivation from RFC 1321; now handles byte order


45 
either statically or dynamically; added missing #include <string.h>


46 
in library.


47 
20020311 lpd Corrected argument list for main(), and added int return


48 
type, in test program and T value program.


49 
20020221 lpd Added missing #include <stdio.h> in test program.


50 
20000703 lpd Patched to eliminate warnings about "constant is


51 
unsigned in ANSI C, signed in traditional"; made test program


52 
selfchecking.


53 
19991104 lpd Edited comments slightly for automatic TOC extraction.


54 
19991018 lpd Fixed typo in header comment (ansi2knr rather than md5).


55 
19990503 lpd Original version.


56 
*/


57 


58 
#include <string.h>


59 


60 
#include "md5.h"


61 


62 
#undef BYTE_ORDER /* 1 = bigendian, 1 = littleendian, 0 = unknown */


63 
//#ifdef ARCH_IS_BIG_ENDIAN


64 
//# define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : 1)


65 
//#else


66 
//# define BYTE_ORDER 0


67 
//#endif


68 
#if PLATFORM_BIGENDIAN


69 
# define BYTE_ORDER 1


70 
#else


71 
# define BYTE_ORDER 1


72 
#endif


73 


74 
#define T_MASK ((uint32_t)~0)


75 
#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)


76 
#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)


77 
#define T3 0x242070db


78 
#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)


79 
#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)


80 
#define T6 0x4787c62a


81 
#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)


82 
#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)


83 
#define T9 0x698098d8


84 
#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)


85 
#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)


86 
#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)


87 
#define T13 0x6b901122


88 
#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)


89 
#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)


90 
#define T16 0x49b40821


91 
#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)


92 
#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)


93 
#define T19 0x265e5a51


94 
#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)


95 
#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)


96 
#define T22 0x02441453


97 
#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)


98 
#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)


99 
#define T25 0x21e1cde6


100 
#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)


101 
#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)


102 
#define T28 0x455a14ed


103 
#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)


104 
#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)


105 
#define T31 0x676f02d9


106 
#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)


107 
#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)


108 
#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)


109 
#define T35 0x6d9d6122


110 
#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)


111 
#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)


112 
#define T38 0x4bdecfa9


113 
#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)


114 
#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)


115 
#define T41 0x289b7ec6


116 
#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)


117 
#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)


118 
#define T44 0x04881d05


119 
#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)


120 
#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)


121 
#define T47 0x1fa27cf8


122 
#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)


123 
#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)


124 
#define T50 0x432aff97


125 
#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)


126 
#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)


127 
#define T53 0x655b59c3


128 
#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)


129 
#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)


130 
#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)


131 
#define T57 0x6fa87e4f


132 
#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)


133 
#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)


134 
#define T60 0x4e0811a1


135 
#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)


136 
#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)


137 
#define T63 0x2ad7d2bb


138 
#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)


139 


140 


141 
static void


142 
MD5_process(MD5_CTX *pms, const uint8_t *data /*[64]*/)


143 
{


144 
uint32_t


145 
a = pms>abcd[0], b = pms>abcd[1],


146 
c = pms>abcd[2], d = pms>abcd[3];


147 
uint32_t t;


148 
#if BYTE_ORDER > 0


149 
/* Define storage only for bigendian CPUs. */


150 
uint32_t X[16];


151 
#else


152 
/* Define storage for littleendian or both types of CPUs. */


153 
uint32_t xbuf[16];


154 
const uint32_t *X;


155 
#endif


156 


157 
{


158 
#if BYTE_ORDER == 0


159 
/*


160 
* Determine dynamically whether this is a bigendian or


161 
* littleendian machine, since we can use a more efficient


162 
* algorithm on the latter.


163 
*/


164 
static const int w = 1;


165 


166 
if (*((const uint8_t *)&w)) /* dynamic littleendian */


167 
#endif


168 
#if BYTE_ORDER <= 0 /* littleendian */


169 
{


170 
/*


171 
* On littleendian machines, we can process properly aligned


172 
* data without copying it.


173 
*/


174 
if (!((data  (const uint8_t *)0) & 3)) {


175 
/* data are properly aligned */


176 
X = (const uint32_t *)data;


177 
} else {


178 
/* not aligned */


179 
memcpy(xbuf, data, 64);


180 
X = xbuf;


181 
}


182 
}


183 
#endif


184 
#if BYTE_ORDER == 0


185 
else /* dynamic bigendian */


186 
#endif


187 
#if BYTE_ORDER >= 0 /* bigendian */


188 
{


189 
/*


190 
* On bigendian machines, we must arrange the bytes in the


191 
* right order.


192 
*/


193 
const uint8_t *xp = data;


194 
int i;


195 


196 
# if BYTE_ORDER == 0


197 
X = xbuf; /* (dynamic only) */


198 
# else


199 
# define xbuf X /* (static only) */


200 
# endif


201 
for (i = 0; i < 16; ++i, xp += 4)


202 
xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);


203 
}


204 
#endif


205 
}


206 


207 
#define ROTATE_LEFT(x, n) (((x) << (n))  ((x) >> (32  (n))))


208 


209 
/* Round 1. */


210 
/* Let [abcd k s i] denote the operation


211 
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */


212 
#define F(x, y, z) (((x) & (y))  (~(x) & (z)))


213 
#define SET(a, b, c, d, k, s, Ti)\


214 
t = a + F(b,c,d) + X[k] + Ti;\


215 
a = ROTATE_LEFT(t, s) + b


216 
/* Do the following 16 operations. */


217 
SET(a, b, c, d, 0, 7, T1);


218 
SET(d, a, b, c, 1, 12, T2);


219 
SET(c, d, a, b, 2, 17, T3);


220 
SET(b, c, d, a, 3, 22, T4);


221 
SET(a, b, c, d, 4, 7, T5);


222 
SET(d, a, b, c, 5, 12, T6);


223 
SET(c, d, a, b, 6, 17, T7);


224 
SET(b, c, d, a, 7, 22, T8);


225 
SET(a, b, c, d, 8, 7, T9);


226 
SET(d, a, b, c, 9, 12, T10);


227 
SET(c, d, a, b, 10, 17, T11);


228 
SET(b, c, d, a, 11, 22, T12);


229 
SET(a, b, c, d, 12, 7, T13);


230 
SET(d, a, b, c, 13, 12, T14);


231 
SET(c, d, a, b, 14, 17, T15);


232 
SET(b, c, d, a, 15, 22, T16);


233 
#undef SET


234 


235 
/* Round 2. */


236 
/* Let [abcd k s i] denote the operation


237 
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */


238 
#define G(x, y, z) (((x) & (z))  ((y) & ~(z)))


239 
#define SET(a, b, c, d, k, s, Ti)\


240 
t = a + G(b,c,d) + X[k] + Ti;\


241 
a = ROTATE_LEFT(t, s) + b


242 
/* Do the following 16 operations. */


243 
SET(a, b, c, d, 1, 5, T17);


244 
SET(d, a, b, c, 6, 9, T18);


245 
SET(c, d, a, b, 11, 14, T19);


246 
SET(b, c, d, a, 0, 20, T20);


247 
SET(a, b, c, d, 5, 5, T21);


248 
SET(d, a, b, c, 10, 9, T22);


249 
SET(c, d, a, b, 15, 14, T23);


250 
SET(b, c, d, a, 4, 20, T24);


251 
SET(a, b, c, d, 9, 5, T25);


252 
SET(d, a, b, c, 14, 9, T26);


253 
SET(c, d, a, b, 3, 14, T27);


254 
SET(b, c, d, a, 8, 20, T28);


255 
SET(a, b, c, d, 13, 5, T29);


256 
SET(d, a, b, c, 2, 9, T30);


257 
SET(c, d, a, b, 7, 14, T31);


258 
SET(b, c, d, a, 12, 20, T32);


259 
#undef SET


260 


261 
/* Round 3. */


262 
/* Let [abcd k s t] denote the operation


263 
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */


264 
#define H(x, y, z) ((x) ^ (y) ^ (z))


265 
#define SET(a, b, c, d, k, s, Ti)\


266 
t = a + H(b,c,d) + X[k] + Ti;\


267 
a = ROTATE_LEFT(t, s) + b


268 
/* Do the following 16 operations. */


269 
SET(a, b, c, d, 5, 4, T33);


270 
SET(d, a, b, c, 8, 11, T34);


271 
SET(c, d, a, b, 11, 16, T35);


272 
SET(b, c, d, a, 14, 23, T36);


273 
SET(a, b, c, d, 1, 4, T37);


274 
SET(d, a, b, c, 4, 11, T38);


275 
SET(c, d, a, b, 7, 16, T39);


276 
SET(b, c, d, a, 10, 23, T40);


277 
SET(a, b, c, d, 13, 4, T41);


278 
SET(d, a, b, c, 0, 11, T42);


279 
SET(c, d, a, b, 3, 16, T43);


280 
SET(b, c, d, a, 6, 23, T44);


281 
SET(a, b, c, d, 9, 4, T45);


282 
SET(d, a, b, c, 12, 11, T46);


283 
SET(c, d, a, b, 15, 16, T47);


284 
SET(b, c, d, a, 2, 23, T48);


285 
#undef SET


286 


287 
/* Round 4. */


288 
/* Let [abcd k s t] denote the operation


289 
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */


290 
#define I(x, y, z) ((y) ^ ((x)  ~(z)))


291 
#define SET(a, b, c, d, k, s, Ti)\


292 
t = a + I(b,c,d) + X[k] + Ti;\


293 
a = ROTATE_LEFT(t, s) + b


294 
/* Do the following 16 operations. */


295 
SET(a, b, c, d, 0, 6, T49);


296 
SET(d, a, b, c, 7, 10, T50);


297 
SET(c, d, a, b, 14, 15, T51);


298 
SET(b, c, d, a, 5, 21, T52);


299 
SET(a, b, c, d, 12, 6, T53);


300 
SET(d, a, b, c, 3, 10, T54);


301 
SET(c, d, a, b, 10, 15, T55);


302 
SET(b, c, d, a, 1, 21, T56);


303 
SET(a, b, c, d, 8, 6, T57);


304 
SET(d, a, b, c, 15, 10, T58);


305 
SET(c, d, a, b, 6, 15, T59);


306 
SET(b, c, d, a, 13, 21, T60);


307 
SET(a, b, c, d, 4, 6, T61);


308 
SET(d, a, b, c, 11, 10, T62);


309 
SET(c, d, a, b, 2, 15, T63);


310 
SET(b, c, d, a, 9, 21, T64);


311 
#undef SET


312 


313 
/* Then perform the following additions. (That is increment each


314 
of the four registers by the value it had before this block


315 
was started.) */


316 
pms>abcd[0] += a;


317 
pms>abcd[1] += b;


318 
pms>abcd[2] += c;


319 
pms>abcd[3] += d;


320 
}


321 


322 
void


323 
MD5_init(MD5_CTX *pms)


324 
{


325 
pms>count[0] = pms>count[1] = 0;


326 
pms>abcd[0] = 0x67452301;


327 
pms>abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;


328 
pms>abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;


329 
pms>abcd[3] = 0x10325476;


330 
}


331 


332 
void


333 
MD5_append(MD5_CTX *pms, const uint8_t *data, int nbytes)


334 
{


335 
const uint8_t *p = data;


336 
int left = nbytes;


337 
int offset = (pms>count[0] >> 3) & 63;


338 
uint32_t nbits = (uint32_t)(nbytes << 3);


339 


340 
if (nbytes <= 0)


341 
return;


342 


343 
/* Update the message length. */


344 
pms>count[1] += nbytes >> 29;


345 
pms>count[0] += nbits;


346 
if (pms>count[0] < nbits)


347 
pms>count[1]++;


348 


349 
/* Process an initial partial block. */


350 
if (offset) {


351 
int copy = (offset + nbytes > 64 ? 64  offset : nbytes);


352 


353 
memcpy(pms>buf + offset, p, copy);


354 
if (offset + copy < 64)


355 
return;


356 
p += copy;


357 
left = copy;


358 
MD5_process(pms, pms>buf);


359 
}


360 


361 
/* Process full blocks. */


362 
for (; left >= 64; p += 64, left = 64)


363 
MD5_process(pms, p);


364 


365 
/* Process a final partial block. */


366 
if (left)


367 
memcpy(pms>buf, p, left);


368 
}


369 


370 
void


371 
MD5_finish(MD5_CTX *pms, uint8_t digest[16])


372 
{


373 
const uint8_t pad[64] = {


374 
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,


375 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,


376 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,


377 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0


378 
};


379 
uint8_t data[8];


380 
int i;


381 


382 
/* Save the length before padding. */


383 
for (i = 0; i < 8; ++i)


384 
data[i] = (uint8_t)(pms>count[i >> 2] >> ((i & 3) << 3));


385 
/* Pad to 56 bytes mod 64. */


386 
MD5_append(pms, pad, ((55  (pms>count[0] >> 3)) & 63) + 1);


387 
/* Append the length. */


388 
MD5_append(pms, data, 8);


389 
for (i = 0; i < 16; ++i)


390 
digest[i] = (uint8_t)(pms>abcd[i >> 2] >> ((i & 3) << 3));


391 
}


392 


393 
// end of md5.c ...


394 
