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 <config.h>
  39
  40 #include <apt-pkg/md5.h>
  41
  42 #include <stdint.h>
  43 #include <string.h>
  44                                                                         /*}}}*/
  45
  46 // byteSwap - Swap bytes in a buffer                                    /*{{{*/
  47 // ---------------------------------------------------------------------
  48 /* Swap n 32 bit longs in given buffer */
  49 #ifdef WORDS_BIGENDIAN
  50 static void byteSwap(uint32_t *buf, unsigned words)
  51 {
  52    uint8_t *p = (uint8_t *)buf;
  53
  54    do
  55    {
  56       *buf++ = (uint32_t)((unsigned)p[3] << 8 | p[2]) << 16 |
  57          ((unsigned)p[1] << 8 | p[0]);
  58       p += 4;
  59    } while (--words);
  60 }
  61 #else
  62 #define byteSwap(buf,words)
  63 #endif
  64                                                                         /*}}}*/
  65 // MD5Transform - Alters an existing MD5 hash                           /*{{{*/
  66 // ---------------------------------------------------------------------
  67 /* The core of the MD5 algorithm, this alters an existing MD5 hash to
  68    reflect the addition of 16 longwords of new data. Add blocks
  69    the data and converts bytes into longwords for this routine. */
  70
  71 // The four core functions - F1 is optimized somewhat
  72 // #define F1(x, y, z) (x & y | ~x & z)
  73 #define F1(x, y, z) (z ^ (x & (y ^ z)))
  74 #define F2(x, y, z) F1(z, x, y)
  75 #define F3(x, y, z) (x ^ y ^ z)
  76 #define F4(x, y, z) (y ^ (x | ~z))
  77
  78 // This is the central step in the MD5 algorithm.
  79 #define MD5STEP(f,w,x,y,z,in,s) \
  80          (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
  81
  82 static void MD5Transform(uint32_t buf[4], uint32_t const in[16])
  83 {
  84    register uint32_t a, b, c, d;
  85
  86    a = buf[0];
  87    b = buf[1];
  88    c = buf[2];
  89    d = buf[3];
  90
  91    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
  92    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
  93    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
  94    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
  95    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
  96    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
  97    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
  98    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
  99    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
 100    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
 101    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
 102    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
 103    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
 104    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
 105    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
 106    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
 107
 108    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
 109    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
 110    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
 111    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
 112    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
 113    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
 114    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
 115    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
 116    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
 117    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
 118    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
 119    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
 120    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
 121    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
 122    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
 123    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
 124
 125    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
 126    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
 127    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
 128    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
 129    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
 130    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
 131    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
 132    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
 133    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
 134    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
 135    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
 136    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
 137    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
 138    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
 139    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
 140    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
 141
 142    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
 143    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
 144    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
 145    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
 146    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
 147    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
 148    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
 149    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
 150    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
 151    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
 152    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
 153    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
 154    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
 155    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
 156    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
 157    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
 158
 159    buf[0] += a;
 160    buf[1] += b;
 161    buf[2] += c;
 162    buf[3] += d;
 163 }
 164                                                                         /*}}}*/
 165 // MD5Summation::MD5Summation - Initialize the summer                   /*{{{*/
 166 // ---------------------------------------------------------------------
 167 /* This assigns the deep magic initial values */
 168 MD5Summation::MD5Summation()
 169 {
 170    uint32_t *buf = (uint32_t *)Buf;
 171    uint32_t *bytes = (uint32_t *)Bytes;
 172
 173    buf[0] = 0x67452301;
 174    buf[1] = 0xefcdab89;
 175    buf[2] = 0x98badcfe;
 176    buf[3] = 0x10325476;
 177
 178    bytes[0] = 0;
 179    bytes[1] = 0;
 180    Done = false;
 181 }
 182                                                                         /*}}}*/
 183 // MD5Summation::Add - 'Add' a data set to the hash                     /*{{{*/
 184 // ---------------------------------------------------------------------
 185 /* */
 186 bool MD5Summation::Add(const unsigned char *data,unsigned long long len)
 187 {
 188    if (Done == true)
 189       return false;
 190    if (len == 0)
 191       return true;
 192
 193    uint32_t *buf = (uint32_t *)Buf;
 194    uint32_t *bytes = (uint32_t *)Bytes;
 195    uint32_t *in = (uint32_t *)In;
 196
 197    // Update byte count and carry (this could be done with a long long?)
 198    uint32_t t = bytes[0];
 199    if ((bytes[0] = t + len) < t)
 200       bytes[1]++;
 201
 202    // Space available (at least 1)
 203    t = 64 - (t & 0x3f);
 204    if (t > len)
 205    {
 206       memcpy((unsigned char *)in + 64 - t,data,len);
 207       return true;
 208    }
 209
 210    // First chunk is an odd size
 211    memcpy((unsigned char *)in + 64 - t,data,t);
 212    byteSwap(in, 16);
 213    MD5Transform(buf,in);
 214    data += t;
 215    len -= t;
 216
 217    // Process data in 64-byte chunks
 218    while (len >= 64)
 219    {
 220       memcpy(in,data,64);
 221       byteSwap(in,16);
 222       MD5Transform(buf,in);
 223       data += 64;
 224       len -= 64;
 225    }
 226
 227    // Handle any remaining bytes of data.
 228    memcpy(in,data,len);
 229
 230    return true;
 231 }
 232                                                                         /*}}}*/
 233 // MD5Summation::Result - Returns the value of the sum                  /*{{{*/
 234 // ---------------------------------------------------------------------
 235 /* Because this must add in the last bytes of the series it prevents anyone
 236    from calling add after. */
 237 MD5SumValue MD5Summation::Result()
 238 {
 239    uint32_t *buf = (uint32_t *)Buf;
 240    uint32_t *bytes = (uint32_t *)Bytes;
 241    uint32_t *in = (uint32_t *)In;
 242
 243    if (Done == false)
 244    {
 245       // Number of bytes in In
 246       int count = bytes[0] & 0x3f;
 247       unsigned char *p = (unsigned char *)in + count;
 248
 249       // Set the first char of padding to 0x80.  There is always room.
 250       *p++ = 0x80;
 251
 252       // Bytes of padding needed to make 56 bytes (-8..55)
 253       count = 56 - 1 - count;
 254
 255       // Padding forces an extra block
 256       if (count < 0)
 257       {
 258          memset(p,0,count + 8);
 259          byteSwap(in, 16);
 260          MD5Transform(buf,in);
 261          p = (unsigned char *)in;
 262          count = 56;
 263       }
 264
 265       memset(p, 0, count);
 266       byteSwap(in, 14);
 267
 268       // Append length in bits and transform
 269       in[14] = bytes[0] << 3;
 270       in[15] = bytes[1] << 3 | bytes[0] >> 29;
 271       MD5Transform(buf,in);
 272       byteSwap(buf,4);
 273       Done = true;
 274    }
 275
 276    MD5SumValue V;
 277    V.Set((unsigned char *)buf);
 278    return V;
 279 }
 280                                                                         /*}}}*/