apt-pkg/contrib/md5.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: md5.cc,v 1.5 1999/10/25 04:10:02 jgg Exp $
   4 /* ######################################################################
   5
   6    MD5Sum - MD5 Message Digest Algorithm.
   7
   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.
  12
  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.
  16
  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.
  20
  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>.
  24
  25    Changed into a C++ interface and made work with APT's config.h.
  26     - Jason Gunthorpe <jgg@gpu.srv.ualberta.ca>
  27
  28    Still in the public domain.
  29
  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
  34
  35    ##################################################################### */
  36                                                                         /*}}}*/
  37 // Include Files                                                        /*{{{*/
  38 #ifdef __GNUG__
  39 #pragma implementation "apt-pkg/md5.h"
  40 #endif
  41
  42 #include <apt-pkg/md5.h>
  43 #include <apt-pkg/strutl.h>
  44
  45 #include <string.h>
  46 #include <system.h>
  47 #include <unistd.h>
  48 #include <netinet/in.h>                          // For htonl
  49 #include <inttypes.h>
  50                                                                         /*}}}*/
  51
  52 // byteSwap - Swap bytes in a buffer                                    /*{{{*/
  53 // ---------------------------------------------------------------------
  54 /* Swap n 32 bit longs in given buffer */
  55 inline static void byteSwap(uint32_t *buf, unsigned words)
  56 {
  57    do
  58    {
  59       *buf++ = htonl(*buf);
  60    }
  61    while (--words);
  62 }
  63                                                                         /*}}}*/
  64 // MD5Transform - Alters an existing MD5 hash                           /*{{{*/
  65 // ---------------------------------------------------------------------
  66 /* The core of the MD5 algorithm, this alters an existing MD5 hash to
  67    reflect the addition of 16 longwords of new data. Add blocks
  68    the data and converts bytes into longwords for this routine. */
  69
  70 // The four core functions - F1 is optimized somewhat
  71 // #define F1(x, y, z) (x & y | ~x & z)
  72 #define F1(x, y, z) (z ^ (x & (y ^ z)))
  73 #define F2(x, y, z) F1(z, x, y)
  74 #define F3(x, y, z) (x ^ y ^ z)
  75 #define F4(x, y, z) (y ^ (x | ~z))
  76
  77 // This is the central step in the MD5 algorithm.
  78 #define MD5STEP(f,w,x,y,z,in,s) \
  79          (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
  80
  81 static void MD5Transform(uint32_t buf[4], uint32_t const in[16])
  82 {
  83    register uint32_t a, b, c, d;
  84
  85    a = buf[0];
  86    b = buf[1];
  87    c = buf[2];
  88    d = buf[3];
  89
  90    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
  91    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
  92    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
  93    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
  94    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
  95    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
  96    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
  97    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
  98    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
  99    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
 100    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
 101    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
 102    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
 103    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
 104    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
 105    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
 106
 107    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
 108    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
 109    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
 110    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
 111    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
 112    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
 113    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
 114    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
 115    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
 116    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
 117    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
 118    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
 119    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
 120    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
 121    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
 122    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
 123
 124    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
 125    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
 126    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
 127    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
 128    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
 129    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
 130    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
 131    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
 132    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
 133    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
 134    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
 135    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
 136    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
 137    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
 138    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
 139    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
 140
 141    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
 142    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
 143    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
 144    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
 145    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
 146    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
 147    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
 148    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
 149    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
 150    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
 151    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
 152    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
 153    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
 154    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
 155    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
 156    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
 157
 158    buf[0] += a;
 159    buf[1] += b;
 160    buf[2] += c;
 161    buf[3] += d;
 162 }
 163                                                                         /*}}}*/
 164 // MD5SumValue::MD5SumValue - Constructs the summation from a string    /*{{{*/
 165 // ---------------------------------------------------------------------
 166 /* The string form of a MD5 is a 32 character hex number */
 167 MD5SumValue::MD5SumValue(string Str)
 168 {
 169    memset(Sum,0,sizeof(Sum));
 170    Set(Str);
 171 }
 172                                                                         /*}}}*/
 173 // MD5SumValue::MD5SumValue - Default constructor                       /*{{{*/
 174 // ---------------------------------------------------------------------
 175 /* Sets the value to 0 */
 176 MD5SumValue::MD5SumValue()
 177 {
 178    memset(Sum,0,sizeof(Sum));
 179 }
 180                                                                         /*}}}*/
 181 // MD5SumValue::Set - Set the sum from a string                         /*{{{*/
 182 // ---------------------------------------------------------------------
 183 /* Converts the hex string into a set of chars */
 184 bool MD5SumValue::Set(string Str)
 185 {
 186    return Hex2Num(Str.begin(),Str.end(),Sum,sizeof(Sum));
 187 }
 188                                                                         /*}}}*/
 189 // MD5SumValue::Value - Convert the number into a string                /*{{{*/
 190 // ---------------------------------------------------------------------
 191 /* Converts the set of chars into a hex string in lower case */
 192 string MD5SumValue::Value() const
 193 {
 194    char Conv[16] = {'0','1','2','3','4','5','6','7','8','9','a','b',
 195                     'c','d','e','f'};
 196    char Result[33];
 197    Result[32] = 0;
 198
 199    // Convert each char into two letters
 200    int J = 0;
 201    int I = 0;
 202    for (; I != 32; J++, I += 2)
 203    {
 204       Result[I] = Conv[Sum[J] >> 4];
 205       Result[I + 1] = Conv[Sum[J] & 0xF];
 206    }
 207
 208    return string(Result);
 209 }
 210                                                                         /*}}}*/
 211 // MD5SumValue::operator == - Comparitor                                /*{{{*/
 212 // ---------------------------------------------------------------------
 213 /* Call memcmp on the buffer */
 214 bool MD5SumValue::operator ==(const MD5SumValue &rhs) const
 215 {
 216    return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
 217 }
 218                                                                         /*}}}*/
 219 // MD5Summation::MD5Summation - Initialize the summer                   /*{{{*/
 220 // ---------------------------------------------------------------------
 221 /* This assigns the deep magic initial values */
 222 MD5Summation::MD5Summation()
 223 {
 224    uint32_t *buf = (uint32_t *)Buf;
 225    uint32_t *bytes = (uint32_t *)Bytes;
 226
 227    buf[0] = 0x67452301;
 228    buf[1] = 0xefcdab89;
 229    buf[2] = 0x98badcfe;
 230    buf[3] = 0x10325476;
 231
 232    bytes[0] = 0;
 233    bytes[1] = 0;
 234    Done = false;
 235 }
 236                                                                         /*}}}*/
 237 // MD5Summation::Add - 'Add' a data set to the hash                     /*{{{*/
 238 // ---------------------------------------------------------------------
 239 /* */
 240 bool MD5Summation::Add(const unsigned char *data,unsigned long len)
 241 {
 242    if (Done == true)
 243       return false;
 244
 245    uint32_t *buf = (uint32_t *)Buf;
 246    uint32_t *bytes = (uint32_t *)Bytes;
 247    uint32_t *in = (uint32_t *)In;
 248
 249    // Update byte count and carry (this could be done with a long long?)
 250    uint32_t t = bytes[0];
 251    if ((bytes[0] = t + len) < t)
 252       bytes[1]++;
 253
 254    // Space available (at least 1)
 255    t = 64 - (t & 0x3f);
 256    if (t > len)
 257    {
 258       memcpy((unsigned char *)in + 64 - t,data,len);
 259       return true;
 260    }
 261
 262    // First chunk is an odd size
 263    memcpy((unsigned char *)in + 64 - t,data,t);
 264    byteSwap(in, 16);
 265    MD5Transform(buf,in);
 266    data += t;
 267    len -= t;
 268
 269    // Process data in 64-byte chunks
 270    while (len >= 64)
 271    {
 272       memcpy(in,data,64);
 273       byteSwap(in,16);
 274       MD5Transform(buf,in);
 275       data += 64;
 276       len -= 64;
 277    }
 278
 279    // Handle any remaining bytes of data.
 280    memcpy(in,data,len);
 281
 282    return true;
 283 }
 284                                                                         /*}}}*/
 285 // MD5Summation::AddFD - Add the contents of a FD to the hash           /*{{{*/
 286 // ---------------------------------------------------------------------
 287 /* */
 288 bool MD5Summation::AddFD(int Fd,unsigned long Size)
 289 {
 290    unsigned char Buf[64*64];
 291    int Res = 0;
 292    while (Size != 0)
 293    {
 294       Res = read(Fd,Buf,MIN(Size,sizeof(Buf)));
 295       if (Res < 0 || (unsigned)Res != MIN(Size,sizeof(Buf)))
 296          return false;
 297       Size -= Res;
 298       Add(Buf,Res);
 299    }
 300    return true;
 301 }
 302                                                                         /*}}}*/
 303 // MD5Summation::Result - Returns the value of the sum                  /*{{{*/
 304 // ---------------------------------------------------------------------
 305 /* Because this must add in the last bytes of the series it prevents anyone
 306    from calling add after. */
 307 MD5SumValue MD5Summation::Result()
 308 {
 309    uint32_t *buf = (uint32_t *)Buf;
 310    uint32_t *bytes = (uint32_t *)Bytes;
 311    uint32_t *in = (uint32_t *)In;
 312
 313    if (Done == false)
 314    {
 315       // Number of bytes in In
 316       int count = bytes[0] & 0x3f;
 317       unsigned char *p = (unsigned char *)in + count;
 318
 319       // Set the first char of padding to 0x80.  There is always room.
 320       *p++ = 0x80;
 321
 322       // Bytes of padding needed to make 56 bytes (-8..55)
 323       count = 56 - 1 - count;
 324
 325       // Padding forces an extra block
 326       if (count < 0)
 327       {
 328          memset(p,0,count + 8);
 329          byteSwap(in, 16);
 330          MD5Transform(buf,in);
 331          p = (unsigned char *)in;
 332          count = 56;
 333       }
 334
 335       memset(p, 0, count);
 336       byteSwap(in, 14);
 337
 338       // Append length in bits and transform
 339       in[14] = bytes[0] << 3;
 340       in[15] = bytes[1] << 3 | bytes[0] >> 29;
 341       MD5Transform(buf,in);
 342       byteSwap(buf,4);
 343       Done = true;
 344    }
 345
 346    MD5SumValue V;
 347    memcpy(V.Sum,buf,16);
 348    return V;
 349 }
 350                                                                         /*}}}*/