apt-pkg/contrib/md5.cc

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