1

/*

     2

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

     3

     4

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

     5

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

     6

  arising from the use of this software.

     7

     8

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

     9

  including commercial applications, and to alter it and redistribute it

    10

  freely, subject to the following restrictions:

    11

    12

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

    13

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

    14

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

    15

     appreciated but is not required.

    16

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

    17

     misrepresented as being the original software.

    18

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

    19

    20

  L. Peter Deutsch

    21

  ghost@aladdin.com

    22

    23

 */

    24

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

    25

/*

    26

  Independent implementation of MD5 (RFC 1321).

    27

    28

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

    29

  text is available at

    30

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

    31

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

    32

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

    33

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

    34

  copyrighted.

    35

    36

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

    37

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

    38

  that follows (in reverse chronological order):

    39

    40

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

    41

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

    42

	in library.

    43

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

    44

	type, in test program and T value program.

    45

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

    46

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

    47

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

    48

	self-checking.

    49

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

    50

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

    51

  1999-05-03 lpd Original version.

    52

 */

    53

    54

#include "stdafx.h"

    55

#include "md5.h"

    56

#include <string.h>

    57

    58

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

    59

#if defined(TTD_BIG_ENDIAN)

    60

#  define BYTE_ORDER 1

    61

#else

    62

#  define BYTE_ORDER -1

    63

#endif

    64

    65

#define T_MASK ((md5_word_t)~0)

    66

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

    67

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

    68

#define T3    0x242070db

    69

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

    70

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

    71

#define T6    0x4787c62a

    72

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

    73

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

    74

#define T9    0x698098d8

    75

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

    76

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

    77

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

    78

#define T13    0x6b901122

    79

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

    80

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

    81

#define T16    0x49b40821

    82

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

    83

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

    84

#define T19    0x265e5a51

    85

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

    86

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

    87

#define T22    0x02441453

    88

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

    89

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

    90

#define T25    0x21e1cde6

    91

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

    92

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

    93

#define T28    0x455a14ed

    94

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

    95

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

    96

#define T31    0x676f02d9

    97

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

    98

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

    99

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

   100

#define T35    0x6d9d6122

   101

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

   102

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

   103

#define T38    0x4bdecfa9

   104

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

   105

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

   106

#define T41    0x289b7ec6

   107

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

   108

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

   109

#define T44    0x04881d05

   110

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

   111

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

   112

#define T47    0x1fa27cf8

   113

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

   114

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

   115

#define T50    0x432aff97

   116

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

   117

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

   118

#define T53    0x655b59c3

   119

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

   120

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

   121

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

   122

#define T57    0x6fa87e4f

   123

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

   124

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

   125

#define T60    0x4e0811a1

   126

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

   127

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

   128

#define T63    0x2ad7d2bb

   129

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

   130

   131

   132

static void

   133

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

   134

{

   135

    md5_word_t

   136

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

   137

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

   138

    md5_word_t t;

   139

#if BYTE_ORDER > 0

   140

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

   141

    md5_word_t X[16];

   142

#else

   143

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

   144

    md5_word_t xbuf[16];

   145

    const md5_word_t *X;

   146

#endif

   147

   148

    {

   149

#if BYTE_ORDER == 0

   150

	/*

   151

	 * Determine dynamically whether this is a big-endian or

   152

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

   153

	 * algorithm on the latter.

   154

	 */

   155

	static const int w = 1;

   156

   157

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

   158

#endif

   159

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

   160

	{

   161

	    /*

   162

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

   163

	     * data without copying it.

   164

	     */

   165

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

   166

		/* data are properly aligned */

   167

		X = (const md5_word_t *)data;

   168

	    } else {

   169

		/* not aligned */

   170

		memcpy(xbuf, data, 64);

   171

		X = xbuf;

   172

	    }

   173

	}

   174

#endif

   175

#if BYTE_ORDER == 0

   176

	else			/* dynamic big-endian */

   177

#endif

   178

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

   179

	{

   180

	    /*

   181

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

   182

	     * right order.

   183

	     */

   184

	    const md5_byte_t *xp = data;

   185

	    int i;

   186

   187

#  if BYTE_ORDER == 0

   188

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

   189

#  else

   190

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

   191

#  endif

   192

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

   193

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

   194

	}

   195

#endif

   196

    }

   197

   198

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

   199

   200

    /* Round 1. */

   201

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

   202

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

   203

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

   204

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

   205

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

   206

  a = ROTATE_LEFT(t, s) + b

   207

    /* Do the following 16 operations. */

   208

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

   209

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

   210

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

   211

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

   212

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

   213

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

   214

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

   215

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

   216

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

   217

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

   218

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

   219

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

   220

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

   221

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

   222

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

   223

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

   224

#undef SET

   225

   226

     /* Round 2. */

   227

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

   228

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

   229

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

   230

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

   231

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

   232

  a = ROTATE_LEFT(t, s) + b

   233

     /* Do the following 16 operations. */

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

#undef SET

   251

   252

     /* Round 3. */

   253

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

   254

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

   255

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

   256

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

   257

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

   258

  a = ROTATE_LEFT(t, s) + b

   259

     /* Do the following 16 operations. */

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

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

   276

#undef SET

   277

   278

     /* Round 4. */

   279

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

   280

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

   281

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

   282

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

   283

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

   284

  a = ROTATE_LEFT(t, s) + b

   285

     /* Do the following 16 operations. */

   286

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

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

#undef SET

   303

   304

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

   305

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

   306

        was started.) */

   307

    pms->abcd[0] += a;

   308

    pms->abcd[1] += b;

   309

    pms->abcd[2] += c;

   310

    pms->abcd[3] += d;

   311

}

   312

   313

void

   314

md5_init(md5_state_t *pms)

   315

{

   316

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

   317

    pms->abcd[0] = 0x67452301;

   318

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

   319

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

   320

    pms->abcd[3] = 0x10325476;

   321

}

   322

   323

void

   324

md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)

   325

{

   326

    const md5_byte_t *p = data;

   327

    int left = nbytes;

   328

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

   329

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

   330

   331

    if (nbytes <= 0)

   332

	return;

   333

   334

    /* Update the message length. */

   335

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

   336

    pms->count[0] += nbits;

   337

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

   338

	pms->count[1]++;

   339

   340

    /* Process an initial partial block. */

   341

    if (offset) {

   342

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

   343

   344

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

   345

	if (offset + copy < 64)

   346

	    return;

   347

	p += copy;

   348

	left -= copy;

   349

	md5_process(pms, pms->buf);

   350

    }

   351

   352

    /* Process full blocks. */

   353

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

   354

	md5_process(pms, p);

   355

   356

    /* Process a final partial block. */

   357

    if (left)

   358

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

   359

}

   360

   361

void

   362

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

   363

{

   364

    static const md5_byte_t pad[64] = {

   365

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

   366

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

   367

	0, 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

    };

   370

    md5_byte_t data[8];

   371

    int i;

   372

   373

    /* Save the length before padding. */

   374

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

   375

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

   376

    /* Pad to 56 bytes mod 64. */

   377

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

   378

    /* Append the length. */

   379

    md5_append(pms, data, 8);

   380

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

   381

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

   382

}