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

  2007-12-24 Changed to C++ and adapted to OpenTTD source

    45

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

    46

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

    47

             in library.

    48

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

    49

             type, in test program and T value program.

    50

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

    51

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

    52

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

    53

             self-checking.

    54

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

    55

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

    56

  1999-05-03 lpd Original version.

    57

 */

    58

    59

#include "stdafx.h"

    60

#include "core/bitmath_func.hpp"

    61

#include "core/endian_func.hpp"

    62

#include "md5.h"

    63

    64

#define T_MASK ((uint32)~0)

    65

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

    66

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

    67

#define T3    0x242070db

    68

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

    69

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

    70

#define T6    0x4787c62a

    71

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

    72

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

    73

#define T9    0x698098d8

    74

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

    75

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

    76

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

    77

#define T13    0x6b901122

    78

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

    79

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

    80

#define T16    0x49b40821

    81

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

    82

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

    83

#define T19    0x265e5a51

    84

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

    85

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

    86

#define T22    0x02441453

    87

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

    88

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

    89

#define T25    0x21e1cde6

    90

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

    91

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

    92

#define T28    0x455a14ed

    93

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

    94

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

    95

#define T31    0x676f02d9

    96

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

    97

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

    98

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

    99

#define T35    0x6d9d6122

   100

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

   101

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

   102

#define T38    0x4bdecfa9

   103

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

   104

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

   105

#define T41    0x289b7ec6

   106

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

   107

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

   108

#define T44    0x04881d05

   109

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

   110

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

   111

#define T47    0x1fa27cf8

   112

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

   113

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

   114

#define T50    0x432aff97

   115

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

   116

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

   117

#define T53    0x655b59c3

   118

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

   119

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

   120

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

   121

#define T57    0x6fa87e4f

   122

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

   123

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

   124

#define T60    0x4e0811a1

   125

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

   126

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

   127

#define T63    0x2ad7d2bb

   128

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

   129

   130

static inline void Md5Set1(const uint32 *X, uint32 *a, const uint32 *b, const uint32 *c, const uint32 *d, const uint8 k, const uint8 s, const uint32 Ti)

   131

{

   132

	uint32 t = (*b & *c) | (~*b & *d);

   133

	t += *a + X[k] + Ti;

   134

	*a = ROL(t, s) + *b;

   135

}

   136

   137

static inline void Md5Set2(const uint32 *X, uint32 *a, const uint32 *b, const uint32 *c, const uint32 *d, const uint8 k, const uint8 s, const uint32 Ti)

   138

{

   139

	uint32 t = (*b & *d) | (*c & ~*d);

   140

	t += *a + X[k] + Ti;

   141

	*a = ROL(t, s) + *b;

   142

}

   143

   144

   145

static inline void Md5Set3(const uint32 *X, uint32 *a, const uint32 *b, const uint32 *c, const uint32 *d, const uint8 k, const uint8 s, const uint32 Ti)

   146

{

   147

	uint32 t = *b ^ *c ^ *d;

   148

	t += *a + X[k] + Ti;

   149

	*a = ROL(t, s) + *b;

   150

}

   151

   152

static inline void Md5Set4(const uint32 *X, uint32 *a, const uint32 *b, const uint32 *c, const uint32 *d, const uint8 k, const uint8 s, const uint32 Ti)

   153

{

   154

	uint32 t = *c ^ (*b | ~*d);

   155

	t += *a + X[k] + Ti;

   156

	*a = ROL(t, s) + *b;

   157

}

   158

   159

Md5::Md5()

   160

{

   161

	count[0] = 0;

   162

	count[1] = 0;

   163

	abcd[0] = 0x67452301;

   164

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

   165

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

   166

	abcd[3] = 0x10325476;

   167

}

   168

   169

void Md5::Process(const uint8 *data /*[64]*/)

   170

{

   171

	uint32 a = this->abcd[0];

   172

	uint32 b = this->abcd[1];

   173

	uint32 c = this->abcd[2];

   174

	uint32 d = this->abcd[3];

   175

   176

	uint32 X[16];

   177

   178

	/* Convert the uint8 data to uint32 LE */

   179

	uint32 *px = (uint32 *)data;

   180

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

   181

		X[i] = TO_LE32(*px);

   182

		px++;

   183

	}

   184

   185

	/* Round 1. */

   186

	Md5Set1(X, &a, &b, &c, &d,  0,  7,  T1);

   187

	Md5Set1(X, &d, &a, &b, &c,  1, 12,  T2);

   188

	Md5Set1(X, &c, &d, &a, &b,  2, 17,  T3);

   189

	Md5Set1(X, &b, &c, &d, &a,  3, 22,  T4);

   190

	Md5Set1(X, &a, &b, &c, &d,  4,  7,  T5);

   191

	Md5Set1(X, &d, &a, &b, &c,  5, 12,  T6);

   192

	Md5Set1(X, &c, &d, &a, &b,  6, 17,  T7);

   193

	Md5Set1(X, &b, &c, &d, &a,  7, 22,  T8);

   194

	Md5Set1(X, &a, &b, &c, &d,  8,  7,  T9);

   195

	Md5Set1(X, &d, &a, &b, &c,  9, 12, T10);

   196

	Md5Set1(X, &c, &d, &a, &b, 10, 17, T11);

   197

	Md5Set1(X, &b, &c, &d, &a, 11, 22, T12);

   198

	Md5Set1(X, &a, &b, &c, &d, 12,  7, T13);

   199

	Md5Set1(X, &d, &a, &b, &c, 13, 12, T14);

   200

	Md5Set1(X, &c, &d, &a, &b, 14, 17, T15);

   201

	Md5Set1(X, &b, &c, &d, &a, 15, 22, T16);

   202

   203

	/* Round 2. */

   204

	Md5Set2(X, &a, &b, &c, &d,  1,  5, T17);

   205

	Md5Set2(X, &d, &a, &b, &c,  6,  9, T18);

   206

	Md5Set2(X, &c, &d, &a, &b, 11, 14, T19);

   207

	Md5Set2(X, &b, &c, &d, &a,  0, 20, T20);

   208

	Md5Set2(X, &a, &b, &c, &d,  5,  5, T21);

   209

	Md5Set2(X, &d, &a, &b, &c, 10,  9, T22);

   210

	Md5Set2(X, &c, &d, &a, &b, 15, 14, T23);

   211

	Md5Set2(X, &b, &c, &d, &a,  4, 20, T24);

   212

	Md5Set2(X, &a, &b, &c, &d,  9,  5, T25);

   213

	Md5Set2(X, &d, &a, &b, &c, 14,  9, T26);

   214

	Md5Set2(X, &c, &d, &a, &b,  3, 14, T27);

   215

	Md5Set2(X, &b, &c, &d, &a,  8, 20, T28);

   216

	Md5Set2(X, &a, &b, &c, &d, 13,  5, T29);

   217

	Md5Set2(X, &d, &a, &b, &c,  2,  9, T30);

   218

	Md5Set2(X, &c, &d, &a, &b,  7, 14, T31);

   219

	Md5Set2(X, &b, &c, &d, &a, 12, 20, T32);

   220

   221

	/* Round 3. */

   222

	Md5Set3(X, &a, &b, &c, &d,  5,  4, T33);

   223

	Md5Set3(X, &d, &a, &b, &c,  8, 11, T34);

   224

	Md5Set3(X, &c, &d, &a, &b, 11, 16, T35);

   225

	Md5Set3(X, &b, &c, &d, &a, 14, 23, T36);

   226

	Md5Set3(X, &a, &b, &c, &d,  1,  4, T37);

   227

	Md5Set3(X, &d, &a, &b, &c,  4, 11, T38);

   228

	Md5Set3(X, &c, &d, &a, &b,  7, 16, T39);

   229

	Md5Set3(X, &b, &c, &d, &a, 10, 23, T40);

   230

	Md5Set3(X, &a, &b, &c, &d, 13,  4, T41);

   231

	Md5Set3(X, &d, &a, &b, &c,  0, 11, T42);

   232

	Md5Set3(X, &c, &d, &a, &b,  3, 16, T43);

   233

	Md5Set3(X, &b, &c, &d, &a,  6, 23, T44);

   234

	Md5Set3(X, &a, &b, &c, &d,  9,  4, T45);

   235

	Md5Set3(X, &d, &a, &b, &c, 12, 11, T46);

   236

	Md5Set3(X, &c, &d, &a, &b, 15, 16, T47);

   237

	Md5Set3(X, &b, &c, &d, &a,  2, 23, T48);

   238

   239

	/* Round 4. */

   240

	Md5Set4(X, &a, &b, &c, &d,  0,  6, T49);

   241

	Md5Set4(X, &d, &a, &b, &c,  7, 10, T50);

   242

	Md5Set4(X, &c, &d, &a, &b, 14, 15, T51);

   243

	Md5Set4(X, &b, &c, &d, &a,  5, 21, T52);

   244

	Md5Set4(X, &a, &b, &c, &d, 12,  6, T53);

   245

	Md5Set4(X, &d, &a, &b, &c,  3, 10, T54);

   246

	Md5Set4(X, &c, &d, &a, &b, 10, 15, T55);

   247

	Md5Set4(X, &b, &c, &d, &a,  1, 21, T56);

   248

	Md5Set4(X, &a, &b, &c, &d,  8,  6, T57);

   249

	Md5Set4(X, &d, &a, &b, &c, 15, 10, T58);

   250

	Md5Set4(X, &c, &d, &a, &b,  6, 15, T59);

   251

	Md5Set4(X, &b, &c, &d, &a, 13, 21, T60);

   252

	Md5Set4(X, &a, &b, &c, &d,  4,  6, T61);

   253

	Md5Set4(X, &d, &a, &b, &c, 11, 10, T62);

   254

	Md5Set4(X, &c, &d, &a, &b,  2, 15, T63);

   255

	Md5Set4(X, &b, &c, &d, &a,  9, 21, T64);

   256

   257

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

   258

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

   259

	 * was started.) */

   260

	this->abcd[0] += a;

   261

	this->abcd[1] += b;

   262

	this->abcd[2] += c;

   263

	this->abcd[3] += d;

   264

}

   265

   266

void Md5::Append(const void *data, const size_t nbytes)

   267

{

   268

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

   269

	size_t left = nbytes;

   270

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

   271

	const uint32 nbits = (uint32)(nbytes << 3);

   272

   273

	if (nbytes <= 0) return;

   274

   275

	/* Update the message length. */

   276

	this->count[1] += (uint32)(nbytes >> 29);

   277

	this->count[0] += nbits;

   278

   279

	if (this->count[0] < nbits) this->count[1]++;

   280

   281

	/* Process an initial partial block. */

   282

	if (offset) {

   283

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

   284

   285

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

   286

   287

		if (offset + copy < 64) return;

   288

   289

		p += copy;

   290

		left -= copy;

   291

		this->Process(this->buf);

   292

	}

   293

   294

	/* Process full blocks. */

   295

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

   296

   297

	/* Process a final partial block. */

   298

	if (left) memcpy(this->buf, p, left);

   299

}

   300

   301

void Md5::Finish(uint8 digest[16])

   302

{

   303

	static const uint8 pad[64] = {

   304

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

   305

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

   306

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

   307

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

   308

	};

   309

	uint8 data[8];

   310

	uint i;

   311

   312

	/* Save the length before padding. */

   313

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

   314

		data[i] = (uint8)(this->count[i >> 2] >> ((i & 3) << 3));

   315

   316

	/* Pad to 56 bytes mod 64. */

   317

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

   318

	/* Append the length. */

   319

	this->Append(data, 8);

   320

   321

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

   322

		digest[i] = (uint8)(this->abcd[i >> 2] >> ((i & 3) << 3));

   323

}