git.saurik.com Git - apt-legacy.git/blob

1 // -*- mode: cpp; mode: fold -*-

2 // Description /*{{{*/

3 // $Id: md5.cc,v 1.12 2001/05/13 05:15:03 jgg Exp $

4 /* ######################################################################

6 MD5Sum - MD5 Message Digest Algorithm.

8 This code implements the MD5 message-digest algorithm. The algorithm is

9 due to Ron Rivest. This code was written by Colin Plumb in 1993, no

10 copyright is claimed. This code is in the public domain; do with it what

11 you wish.

13 Equivalent code is available from RSA Data Security, Inc. This code has

14 been tested against that, and is equivalent, except that you don't need to

15 include two pages of legalese with every copy.

17 To compute the message digest of a chunk of bytes, instantiate the class,

18 and repeatedly call one of the Add() members. When finished the Result

19 method will return the Hash and finalize the value.

21 Changed so as no longer to depend on Colin Plumb's `usual.h' header

22 definitions; now uses stuff from dpkg's config.h.

23 - Ian Jackson <ijackson@nyx.cs.du.edu>.

25 Changed into a C++ interface and made work with APT's config.h.

26 - Jason Gunthorpe <jgg@gpu.srv.ualberta.ca>

28 Still in the public domain.

30 The classes use arrays of char that are a specific size. We cast those

31 arrays to uint8_t's and go from there. This allows us to advoid using

32 the uncommon inttypes.h in a public header or internally newing memory.

33 In theory if C9x becomes nicely accepted

35 ##################################################################### */

36 /*}}}*/

37 // Include Files /*{{{*/

38 #include <apt-pkg/md5.h>

39 #include <apt-pkg/strutl.h>

40 #include <apt-pkg/macros.h>

42 #include <string.h>

43 #include <unistd.h>

44 #include <netinet/in.h> // For htonl

45 #include <inttypes.h>

46 #include <config.h>

47 /*}}}*/

49 // byteSwap - Swap bytes in a buffer /*{{{*/

50 // ---------------------------------------------------------------------

51 /* Swap n 32 bit longs in given buffer */

52 #ifdef WORDS_BIGENDIAN

 static void byteSwap(uint32_t *buf, unsigned words)

54 {

    uint8_t *p = (uint8_t *)buf;

57 do

58 {

       *buf++ = (uint32_t)((unsigned)p[3] << 8 | p[2]) << 16 |

          ((unsigned)p[1] << 8 | p[0]);

61 p += 4;

62 } while (--words);

63 }

64 #else

65 #define byteSwap(buf,words)

66 #endif

67 /*}}}*/

68 // MD5Transform - Alters an existing MD5 hash /*{{{*/

69 // ---------------------------------------------------------------------

70 /* The core of the MD5 algorithm, this alters an existing MD5 hash to

71 reflect the addition of 16 longwords of new data. Add blocks

72 the data and converts bytes into longwords for this routine. */

74 // The four core functions - F1 is optimized somewhat

75 // #define F1(x, y, z) (x & y | ~x & z)

76 #define F1(x, y, z) (z ^ (x & (y ^ z)))

77 #define F2(x, y, z) F1(z, x, y)

78 #define F3(x, y, z) (x ^ y ^ z)

79 #define F4(x, y, z) (y ^ (x | ~z))

81 // This is the central step in the MD5 algorithm.

82 #define MD5STEP(f,w,x,y,z,in,s) \

83 (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)

 static void MD5Transform(uint32_t buf[4], uint32_t const in[16])

86 {

    register uint32_t a, b, c, d;

89 a = buf[0];

90 b = buf[1];

91 c = buf[2];

92 d = buf[3];

    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);

    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);

    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);

    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);

    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);

    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);

    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);

    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);

    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);

    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);

    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);

    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);

    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);

    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);

    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);

    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);

110

    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);

    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);

    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);

    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);

    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);

    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);

    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);

    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);

    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);

    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);

    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);

    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);

    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);

    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);

    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);

    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);

127

    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);

    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);

    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);

    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);

    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);

    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);

    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);

    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);

    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);

    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);

    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);

    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);

    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);

    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);

    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);

    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);

144

    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);

    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);

    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);

    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);

    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);

    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);

    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);

    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);

    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);

    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);

    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);

    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);

    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);

    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);

    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);

    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);

161

162 buf[0] += a;

163 buf[1] += b;

164 buf[2] += c;

165 buf[3] += d;

166 }

167 /*}}}*/

168 // MD5SumValue::MD5SumValue - Constructs the summation from a string /*{{{*/

169 // ---------------------------------------------------------------------

170 /* The string form of a MD5 is a 32 character hex number */

 MD5SumValue::MD5SumValue(string Str)

172 {

    memset(Sum,0,sizeof(Sum));

174 Set(Str);

175 }

176

 MD5SumValue::MD5SumValue(const srkString &Str)

178 {

    memset(Sum, 0, sizeof(Sum));

180 Set(Str);

181 }

182 /*}}}*/

183 // MD5SumValue::MD5SumValue - Default constructor /*{{{*/

184 // ---------------------------------------------------------------------

185 /* Sets the value to 0 */

186 MD5SumValue::MD5SumValue()

187 {

    memset(Sum,0,sizeof(Sum));

189 }

190 /*}}}*/

191 // MD5SumValue::Set - Set the sum from a string /*{{{*/

192 // ---------------------------------------------------------------------

193 /* Converts the hex string into a set of chars */

 bool MD5SumValue::Set(string Str)

195 {

    return Hex2Num(Str,Sum,sizeof(Sum));

197 }

198

 bool MD5SumValue::Set(const srkString &Str)

200 {

    return Hex2Num(Str,Sum,sizeof(Sum));

202 }

203 /*}}}*/

204 // MD5SumValue::Value - Convert the number into a string /*{{{*/

205 // ---------------------------------------------------------------------

206 /* Converts the set of chars into a hex string in lower case */

 string MD5SumValue::Value() const

208 {

    char Conv[16] = {'0','1','2','3','4','5','6','7','8','9','a','b',

                     'c','d','e','f'};

211 char Result[33];

    Result[32] = 0;

213

214 // Convert each char into two letters

215 int J = 0;

216 int I = 0;

    for (; I != 32; J++, I += 2)

218 {

       Result[I] = Conv[Sum[J] >> 4];

       Result[I + 1] = Conv[Sum[J] & 0xF];

221 }

222

223 return string(Result);

224 }

225 /*}}}*/

226 // MD5SumValue::operator == - Comparitor /*{{{*/

227 // ---------------------------------------------------------------------

228 /* Call memcmp on the buffer */

 bool MD5SumValue::operator ==(const MD5SumValue &rhs) const

230 {

    return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;

232 }

233 /*}}}*/

234 // MD5Summation::MD5Summation - Initialize the summer /*{{{*/

235 // ---------------------------------------------------------------------

236 /* This assigns the deep magic initial values */

237 MD5Summation::MD5Summation()

238 {

    uint32_t *buf = (uint32_t *)Buf;

    uint32_t *bytes = (uint32_t *)Bytes;

241

    buf[0] = 0x67452301;

    buf[1] = 0xefcdab89;

    buf[2] = 0x98badcfe;

    buf[3] = 0x10325476;

246

    bytes[0] = 0;

    bytes[1] = 0;

249 Done = false;

250 }

251 /*}}}*/

252 // MD5Summation::Add - 'Add' a data set to the hash /*{{{*/

253 // ---------------------------------------------------------------------

254 /* */

 bool MD5Summation::Add(const unsigned char *data,unsigned long len)

256 {

    if (Done == true)

258 return false;

259

    uint32_t *buf = (uint32_t *)Buf;

    uint32_t *bytes = (uint32_t *)Bytes;

    uint32_t *in = (uint32_t *)In;

263

264 // Update byte count and carry (this could be done with a long long?)

    uint32_t t = bytes[0];

    if ((bytes[0] = t + len) < t)

267 bytes[1]++;

268

269 // Space available (at least 1)

    t = 64 - (t & 0x3f); 

271 if (t > len)

272 {

       memcpy((unsigned char *)in + 64 - t,data,len);

274 return true;

275 }

276

277 // First chunk is an odd size

    memcpy((unsigned char *)in + 64 - t,data,t);

    byteSwap(in, 16);

280 MD5Transform(buf,in);

281 data += t;

282 len -= t;

283

284 // Process data in 64-byte chunks

    while (len >= 64)

286 {

       memcpy(in,data,64);

       byteSwap(in,16);

289 MD5Transform(buf,in);

290 data += 64;

291 len -= 64;

292 }

293

294 // Handle any remaining bytes of data.

    memcpy(in,data,len);

296

297 return true;

298 }

299 /*}}}*/

300 // MD5Summation::AddFD - Add the contents of a FD to the hash /*{{{*/

301 // ---------------------------------------------------------------------

302 /* */

 bool MD5Summation::AddFD(int Fd,unsigned long Size)

304 {

    unsigned char Buf[64*64];

306 int Res = 0;

    int ToEOF = (Size == 0);

    while (Size != 0 || ToEOF)

309 {

       unsigned n = sizeof(Buf);

       if (!ToEOF) n = min(Size,(unsigned long)n);

       Res = read(Fd,Buf,n);

       if (Res < 0 || (!ToEOF && (unsigned) Res != n)) // error, or short read

314 return false;

       if (ToEOF && Res == 0) // EOF

316 break;

317 Size -= Res;

318 Add(Buf,Res);

319 }

320 return true;

321 }

322 /*}}}*/

323 // MD5Summation::Result - Returns the value of the sum /*{{{*/

324 // ---------------------------------------------------------------------

325 /* Because this must add in the last bytes of the series it prevents anyone

326 from calling add after. */

327 MD5SumValue MD5Summation::Result()

328 {

    uint32_t *buf = (uint32_t *)Buf;

    uint32_t *bytes = (uint32_t *)Bytes;

    uint32_t *in = (uint32_t *)In;

332

    if (Done == false)

334 {

335 // Number of bytes in In

       int count = bytes[0] & 0x3f;      

       unsigned char *p = (unsigned char *)in + count;

338

339 // Set the first char of padding to 0x80. There is always room.

340 *p++ = 0x80;

341

342 // Bytes of padding needed to make 56 bytes (-8..55)

       count = 56 - 1 - count;

344

345 // Padding forces an extra block

       if (count < 0) 

347 {

          memset(p,0,count + 8);

          byteSwap(in, 16);

350 MD5Transform(buf,in);

351 p = (unsigned char *)in;

352 count = 56;

353 }

354

       memset(p, 0, count);

       byteSwap(in, 14);

357

358 // Append length in bits and transform

       in[14] = bytes[0] << 3;

       in[15] = bytes[1] << 3 | bytes[0] >> 29;

361 MD5Transform(buf,in);

       byteSwap(buf,4);

363 Done = true;

364 }

365

366 MD5SumValue V;

    memcpy(V.Sum,buf,16);

368 return V;

369 }

370 /*}}}*/