1

/* $Id$ */

     2

     3

/*

     4

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

     5

     6

  This software is provided 'as-is', without any express or implied

     7

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

     8

  arising from the use of this software.

     9

    10

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

    11

  including commercial applications, and to alter it and redistribute it

    12

  freely, subject to the following restrictions:

    13

    14

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

    15

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

    16

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

    17

     appreciated but is not required.

    18

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

    19

     misrepresented as being the original software.

    20

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

    21

    22

  L. Peter Deutsch

    23

  ghost@aladdin.com

    24

    25

 */

    26

/* $Id$ */

    27

/*

    28

  Independent implementation of MD5 (RFC 1321).

    29

    30

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

    31

  text is available at

    32

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

    33

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

    34

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

    35

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

    36

  copyrighted.

    37

    38

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

    39

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

    40

  that follows (in reverse chronological order):

    41

    42

  2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order

    43

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

    44

	in library.

    45

  2002-03-11 lpd Corrected argument list for main(), and added int return

    46

	type, in test program and T value program.

    47

  2002-02-21 lpd Added missing #include <stdio.h> in test program.

    48

  2000-07-03 lpd Patched to eliminate warnings about "constant is

    49

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

    50

	self-checking.

    51

  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.

    52

  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).

    53

  1999-05-03 lpd Original version.

    54

 */

    55

    56

#include "stdafx.h"

    57

#include "md5.h"

    58

#include <string.h>

    59

    60

#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */

    61

#if defined(TTD_BIG_ENDIAN)

    62

#  define BYTE_ORDER 1

    63

#else

    64

#  define BYTE_ORDER -1

    65

#endif

    66

    67

#define T_MASK ((md5_word_t)~0)

    68

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

    69

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

    70

#define T3    0x242070db

    71

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

    72

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

    73

#define T6    0x4787c62a

    74

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

    75

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

    76

#define T9    0x698098d8

    77

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

    78

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

    79

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

    80

#define T13    0x6b901122

    81

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

    82

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

    83

#define T16    0x49b40821

    84

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

    85

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

    86

#define T19    0x265e5a51

    87

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

    88

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

    89

#define T22    0x02441453

    90

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

    91

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

    92

#define T25    0x21e1cde6

    93

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

    94

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

    95

#define T28    0x455a14ed

    96

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

    97

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

    98

#define T31    0x676f02d9

    99

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

   100

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

   101

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

   102

#define T35    0x6d9d6122

   103

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

   104

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

   105

#define T38    0x4bdecfa9

   106

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

   107

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

   108

#define T41    0x289b7ec6

   109

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

   110

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

   111

#define T44    0x04881d05

   112

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

   113

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

   114

#define T47    0x1fa27cf8

   115

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

   116

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

   117

#define T50    0x432aff97

   118

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

   119

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

   120

#define T53    0x655b59c3

   121

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

   122

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

   123

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

   124

#define T57    0x6fa87e4f

   125

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

   126

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

   127

#define T60    0x4e0811a1

   128

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

   129

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

   130

#define T63    0x2ad7d2bb

   131

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

   132

   133

   134

static void

   135

md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)

   136

{

   137

    md5_word_t

   138

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

   139

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

   140

    md5_word_t t;

   141

#if BYTE_ORDER > 0

   142

    /* Define storage only for big-endian CPUs. */

   143

    md5_word_t X[16];

   144

#else

   145

    /* Define storage for little-endian or both types of CPUs. */

   146

    md5_word_t xbuf[16];

   147

    const md5_word_t *X;

   148

#endif

   149

   150

    {

   151

#if BYTE_ORDER == 0

   152

	/*

   153

	 * Determine dynamically whether this is a big-endian or

   154

	 * little-endian machine, since we can use a more efficient

   155

	 * algorithm on the latter.

   156

	 */

   157

	static const int w = 1;

   158

   159

	if (*((const md5_byte_t *)&w)) /* dynamic little-endian */

   160

#endif

   161

#if BYTE_ORDER <= 0 /* little-endian */

   162

	{

   163

	    /*

   164

	     * On little-endian machines, we can process properly aligned

   165

	     * data without copying it.

   166

	     */

   167

	    if (!((data - (const md5_byte_t *)0) & 3)) {

   168

		/* data are properly aligned */

   169

		X = (const md5_word_t *)data;

   170

	    } else {

   171

		/* not aligned */

   172

		memcpy(xbuf, data, 64);

   173

		X = xbuf;

   174

	    }

   175

	}

   176

#endif

   177

#if BYTE_ORDER == 0

   178

	else /* dynamic big-endian */

   179

#endif

   180

#if BYTE_ORDER >= 0 /* big-endian */

   181

	{

   182

	    /*

   183

	     * On big-endian machines, we must arrange the bytes in the

   184

	     * right order.

   185

	     */

   186

	    const md5_byte_t *xp = data;

   187

	    int i;

   188

   189

#  if BYTE_ORDER == 0

   190

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

   191

#  else

   192

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

   193

#  endif

   194

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

   195

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

   196

	}

   197

#endif

   198

    }

   199

   200

#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))

   201

   202

    /* Round 1. */

   203

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

   204

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

   205

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

   206

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

   207

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

   208

  a = ROTATE_LEFT(t, s) + b

   209

    /* Do the following 16 operations. */

   210

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

   211

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

   212

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

   213

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

   214

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

   215

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

   216

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

   217

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

   218

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

   219

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

   220

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

   221

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

   222

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

   223

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

   224

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

   225

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

   226

#undef SET

   227

   228

     /* Round 2. */

   229

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

   230

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

   231

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

   232

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

   233

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

   234

  a = ROTATE_LEFT(t, s) + b

   235

     /* Do the following 16 operations. */

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

#undef SET

   253

   254

     /* Round 3. */

   255

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

   256

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

   257

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

   258

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

   259

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

   260

  a = ROTATE_LEFT(t, s) + b

   261

     /* Do the following 16 operations. */

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

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

   276

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

   277

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

   278

#undef SET

   279

   280

     /* Round 4. */

   281

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

   282

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

   283

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

   284

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

   285

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

   286

  a = ROTATE_LEFT(t, s) + b

   287

     /* Do the following 16 operations. */

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

#undef SET

   305

   306

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

   307

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

   308

        was started.) */

   309

    pms->abcd[0] += a;

   310

    pms->abcd[1] += b;

   311

    pms->abcd[2] += c;

   312

    pms->abcd[3] += d;

   313

}

   314

   315

void

   316

md5_init(md5_state_t *pms)

   317

{

   318

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

   319

    pms->abcd[0] = 0x67452301;

   320

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

   321

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

   322

    pms->abcd[3] = 0x10325476;

   323

}

   324

   325

void

   326

md5_append(md5_state_t *pms, const void *data, size_t nbytes)

   327

{

   328

    const md5_byte_t *p = (const md5_byte_t *)data;

   329

    size_t left = nbytes;

   330

    size_t offset = (pms->count[0] >> 3) & 63;

   331

    md5_word_t nbits = (md5_word_t)(nbytes << 3);

   332

   333

    if (nbytes <= 0)

   334

	return;

   335

   336

    /* Update the message length. */

   337

    pms->count[1] += (md5_word_t)(nbytes >> 29);

   338

    pms->count[0] += nbits;

   339

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

   340

	pms->count[1]++;

   341

   342

    /* Process an initial partial block. */

   343

    if (offset) {

   344

	size_t copy = (offset + nbytes > 64 ? 64 - offset : nbytes);

   345

   346

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

   347

	if (offset + copy < 64)

   348

	    return;

   349

	p += copy;

   350

	left -= copy;

   351

	md5_process(pms, pms->buf);

   352

    }

   353

   354

    /* Process full blocks. */

   355

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

   356

	md5_process(pms, p);

   357

   358

    /* Process a final partial block. */

   359

    if (left)

   360

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

   361

}

   362

   363

void

   364

md5_finish(md5_state_t *pms, md5_byte_t digest[16])

   365

{

   366

    static const md5_byte_t pad[64] = {

   367

	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   368

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   369

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   370

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

   371

    };

   372

    md5_byte_t data[8];

   373

    int i;

   374

   375

    /* Save the length before padding. */

   376

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

   377

	data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));

   378

    /* Pad to 56 bytes mod 64. */

   379

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

   380

    /* Append the length. */

   381

    md5_append(pms, data, 8);

   382

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

   383

	digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));

   384

}