1

/* $Id$ */

     2

     3

/** @file md5.cpp */

     4

     5

/*

     6

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

     7

     8

  This software is provided 'as-is', 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

    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

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

    45

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

    46

	in library.

    47

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

    48

	type, in test program and T value program.

    49

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

    50

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

    51

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

    52

	self-checking.

    53

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

    54

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

    55

  1999-05-03 lpd Original version.

    56

 */

    57

    58

#include "stdafx.h"

    59

#include "md5.h"

    60

#include <string.h>

    61

    62

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

    63

#if defined(TTD_BIG_ENDIAN)

    64

#  define BYTE_ORDER 1

    65

#else

    66

#  define BYTE_ORDER -1

    67

#endif

    68

    69

#define T_MASK ((md5_word_t)~0)

    70

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

    71

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

    72

#define T3    0x242070db

    73

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

    74

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

    75

#define T6    0x4787c62a

    76

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

    77

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

    78

#define T9    0x698098d8

    79

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

    80

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

    81

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

    82

#define T13    0x6b901122

    83

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

    84

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

    85

#define T16    0x49b40821

    86

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

    87

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

    88

#define T19    0x265e5a51

    89

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

    90

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

    91

#define T22    0x02441453

    92

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

    93

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

    94

#define T25    0x21e1cde6

    95

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

    96

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

    97

#define T28    0x455a14ed

    98

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

    99

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

   100

#define T31    0x676f02d9

   101

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

   102

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

   103

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

   104

#define T35    0x6d9d6122

   105

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

   106

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

   107

#define T38    0x4bdecfa9

   108

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

   109

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

   110

#define T41    0x289b7ec6

   111

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

   112

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

   113

#define T44    0x04881d05

   114

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

   115

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

   116

#define T47    0x1fa27cf8

   117

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

   118

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

   119

#define T50    0x432aff97

   120

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

   121

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

   122

#define T53    0x655b59c3

   123

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

   124

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

   125

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

   126

#define T57    0x6fa87e4f

   127

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

   128

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

   129

#define T60    0x4e0811a1

   130

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

   131

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

   132

#define T63    0x2ad7d2bb

   133

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

   134

   135

   136

static void

   137

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

   138

{

   139

    md5_word_t

   140

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

   141

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

   142

    md5_word_t t;

   143

#if BYTE_ORDER > 0

   144

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

   145

    md5_word_t X[16];

   146

#else

   147

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

   148

    md5_word_t xbuf[16];

   149

    const md5_word_t *X;

   150

#endif

   151

   152

    {

   153

#if BYTE_ORDER == 0

   154

	/*

   155

	 * Determine dynamically whether this is a big-endian or

   156

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

   157

	 * algorithm on the latter.

   158

	 */

   159

	static const int w = 1;

   160

   161

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

   162

#endif

   163

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

   164

	{

   165

	    /*

   166

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

   167

	     * data without copying it.

   168

	     */

   169

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

   170

		/* data are properly aligned */

   171

		X = (const md5_word_t *)data;

   172

	    } else {

   173

		/* not aligned */

   174

		memcpy(xbuf, data, 64);

   175

		X = xbuf;

   176

	    }

   177

	}

   178

#endif

   179

#if BYTE_ORDER == 0

   180

	else /* dynamic big-endian */

   181

#endif

   182

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

   183

	{

   184

	    /*

   185

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

   186

	     * right order.

   187

	     */

   188

	    const md5_byte_t *xp = data;

   189

	    int i;

   190

   191

#  if BYTE_ORDER == 0

   192

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

   193

#  else

   194

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

   195

#  endif

   196

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

   197

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

   198

	}

   199

#endif

   200

    }

   201

   202

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

   203

   204

    /* Round 1. */

   205

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

   206

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

   207

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

   208

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

   209

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

   210

  a = ROTATE_LEFT(t, s) + b

   211

    /* Do the following 16 operations. */

   212

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

   213

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

   214

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

   215

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

   216

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

   217

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

   218

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

   219

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

   220

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

   221

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

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

#undef SET

   229

   230

     /* Round 2. */

   231

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

   232

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

   233

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

   234

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

   235

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

   236

  a = ROTATE_LEFT(t, s) + b

   237

     /* Do the following 16 operations. */

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

#undef SET

   255

   256

     /* Round 3. */

   257

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

   258

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

   259

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

   260

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

   261

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

   262

  a = ROTATE_LEFT(t, s) + b

   263

     /* Do the following 16 operations. */

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

#undef SET

   281

   282

     /* Round 4. */

   283

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

   284

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

   285

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

   286

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

   287

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

   288

  a = ROTATE_LEFT(t, s) + b

   289

     /* Do the following 16 operations. */

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

#undef SET

   307

   308

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

   309

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

   310

        was started.) */

   311

    pms->abcd[0] += a;

   312

    pms->abcd[1] += b;

   313

    pms->abcd[2] += c;

   314

    pms->abcd[3] += d;

   315

}

   316

   317

void

   318

md5_init(md5_state_t *pms)

   319

{

   320

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

   321

    pms->abcd[0] = 0x67452301;

   322

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

   323

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

   324

    pms->abcd[3] = 0x10325476;

   325

}

   326

   327

void

   328

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

   329

{

   330

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

   331

    size_t left = nbytes;

   332

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

   333

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

   334

   335

    if (nbytes <= 0)

   336

	return;

   337

   338

    /* Update the message length. */

   339

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

   340

    pms->count[0] += nbits;

   341

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

   342

	pms->count[1]++;

   343

   344

    /* Process an initial partial block. */

   345

    if (offset) {

   346

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

   347

   348

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

   349

	if (offset + copy < 64)

   350

	    return;

   351

	p += copy;

   352

	left -= copy;

   353

	md5_process(pms, pms->buf);

   354

    }

   355

   356

    /* Process full blocks. */

   357

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

   358

	md5_process(pms, p);

   359

   360

    /* Process a final partial block. */

   361

    if (left)

   362

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

   363

}

   364

   365

void

   366

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

   367

{

   368

    static const md5_byte_t pad[64] = {

   369

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

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

   372

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

   373

    };

   374

    md5_byte_t data[8];

   375

    int i;

   376

   377

    /* Save the length before padding. */

   378

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

   379

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

   380

    /* Pad to 56 bytes mod 64. */

   381

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

   382

    /* Append the length. */

   383

    md5_append(pms, data, 8);

   384

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

   385

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

   386

}