lib/xpdf/Decrypt.cc

   1 //========================================================================
   2 //
   3 // Decrypt.cc
   4 //
   5 // Copyright 1996-2003 Glyph & Cog, LLC
   6 //
   7 //========================================================================
   8
   9 #include <aconf.h>
  10
  11 #ifdef USE_GCC_PRAGMAS
  12 #pragma implementation
  13 #endif
  14
  15 #include <string.h>
  16 #include "gmem.h"
  17 #include "Decrypt.h"
  18
  19 static void rc4InitKey(Guchar *key, int keyLen, Guchar *state);
  20 static Guchar rc4DecryptByte(Guchar *state, Guchar *x, Guchar *y, Guchar c);
  21 static void md5(Guchar *msg, int msgLen, Guchar *digest);
  22
  23 static Guchar passwordPad[32] = {
  24   0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41,
  25   0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08,
  26   0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80,
  27   0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a
  28 };
  29
  30 //------------------------------------------------------------------------
  31 // Decrypt
  32 //------------------------------------------------------------------------
  33
  34 Decrypt::Decrypt(Guchar *fileKey, int keyLength, int objNum, int objGen) {
  35   int i;
  36
  37   // construct object key
  38   for (i = 0; i < keyLength; ++i) {
  39     objKey[i] = fileKey[i];
  40   }
  41   objKey[keyLength] = objNum & 0xff;
  42   objKey[keyLength + 1] = (objNum >> 8) & 0xff;
  43   objKey[keyLength + 2] = (objNum >> 16) & 0xff;
  44   objKey[keyLength + 3] = objGen & 0xff;
  45   objKey[keyLength + 4] = (objGen >> 8) & 0xff;
  46   md5(objKey, keyLength + 5, objKey);
  47
  48   // set up for decryption
  49   x = y = 0;
  50   if ((objKeyLength = keyLength + 5) > 16) {
  51     objKeyLength = 16;
  52   }
  53   rc4InitKey(objKey, objKeyLength, state);
  54 }
  55
  56 void Decrypt::reset() {
  57   x = y = 0;
  58   rc4InitKey(objKey, objKeyLength, state);
  59 }
  60
  61 Guchar Decrypt::decryptByte(Guchar c) {
  62   return rc4DecryptByte(state, &x, &y, c);
  63 }
  64
  65 GBool Decrypt::makeFileKey(int encVersion, int encRevision, int keyLength,
  66                            GString *ownerKey, GString *userKey,
  67                            int permissions, GString *fileID,
  68                            GString *ownerPassword, GString *userPassword,
  69                            Guchar *fileKey, GBool encryptMetadata,
  70                            GBool *ownerPasswordOk) {
  71   Guchar test[32], test2[32];
  72   GString *userPassword2;
  73   Guchar fState[256];
  74   Guchar tmpKey[16];
  75   Guchar fx, fy;
  76   int len, i, j;
  77
  78   // try using the supplied owner password to generate the user password
  79   *ownerPasswordOk = gFalse;
  80   if (ownerPassword) {
  81     len = ownerPassword->getLength();
  82     if (len < 32) {
  83       memcpy(test, ownerPassword->getCString(), len);
  84       memcpy(test + len, passwordPad, 32 - len);
  85     } else {
  86       memcpy(test, ownerPassword->getCString(), 32);
  87     }
  88     md5(test, 32, test);
  89     if (encRevision == 3) {
  90       for (i = 0; i < 50; ++i) {
  91         md5(test, 16, test);
  92       }
  93     }
  94     if (encRevision == 2) {
  95       rc4InitKey(test, keyLength, fState);
  96       fx = fy = 0;
  97       for (i = 0; i < 32; ++i) {
  98         test2[i] = rc4DecryptByte(fState, &fx, &fy, ownerKey->getChar(i));
  99       }
 100     } else {
 101       memcpy(test2, ownerKey->getCString(), 32);
 102       for (i = 19; i >= 0; --i) {
 103         for (j = 0; j < keyLength; ++j) {
 104           tmpKey[j] = test[j] ^ i;
 105         }
 106         rc4InitKey(tmpKey, keyLength, fState);
 107         fx = fy = 0;
 108         for (j = 0; j < 32; ++j) {
 109           test2[j] = rc4DecryptByte(fState, &fx, &fy, test2[j]);
 110         }
 111       }
 112     }
 113     userPassword2 = new GString((char *)test2, 32);
 114     if (makeFileKey2(encVersion, encRevision, keyLength, ownerKey, userKey,
 115                      permissions, fileID, userPassword2, fileKey,
 116                      encryptMetadata)) {
 117       *ownerPasswordOk = gTrue;
 118       delete userPassword2;
 119       return gTrue;
 120     }
 121     delete userPassword2;
 122   }
 123
 124   // try using the supplied user password
 125   return makeFileKey2(encVersion, encRevision, keyLength, ownerKey, userKey,
 126                       permissions, fileID, userPassword, fileKey,
 127                       encryptMetadata);
 128 }
 129
 130 GBool Decrypt::makeFileKey2(int encVersion, int encRevision, int keyLength,
 131                             GString *ownerKey, GString *userKey,
 132                             int permissions, GString *fileID,
 133                             GString *userPassword, Guchar *fileKey,
 134                             GBool encryptMetadata) {
 135   Guchar *buf;
 136   Guchar test[32];
 137   Guchar fState[256];
 138   Guchar tmpKey[16];
 139   Guchar fx, fy;
 140   int len, i, j;
 141   GBool ok;
 142
 143   // generate file key
 144   buf = (Guchar *)gmalloc(72 + fileID->getLength());
 145   if (userPassword) {
 146     len = userPassword->getLength();
 147     if (len < 32) {
 148       memcpy(buf, userPassword->getCString(), len);
 149       memcpy(buf + len, passwordPad, 32 - len);
 150     } else {
 151       memcpy(buf, userPassword->getCString(), 32);
 152     }
 153   } else {
 154     memcpy(buf, passwordPad, 32);
 155   }
 156   memcpy(buf + 32, ownerKey->getCString(), 32);
 157   buf[64] = permissions & 0xff;
 158   buf[65] = (permissions >> 8) & 0xff;
 159   buf[66] = (permissions >> 16) & 0xff;
 160   buf[67] = (permissions >> 24) & 0xff;
 161   memcpy(buf + 68, fileID->getCString(), fileID->getLength());
 162   len = 68 + fileID->getLength();
 163   if (!encryptMetadata) {
 164     buf[len++] = 0xff;
 165     buf[len++] = 0xff;
 166     buf[len++] = 0xff;
 167     buf[len++] = 0xff;
 168   }
 169   md5(buf, len, fileKey);
 170   if (encRevision == 3) {
 171     for (i = 0; i < 50; ++i) {
 172       md5(fileKey, keyLength, fileKey);
 173     }
 174   }
 175
 176   // test user password
 177   if (encRevision == 2) {
 178     rc4InitKey(fileKey, keyLength, fState);
 179     fx = fy = 0;
 180     for (i = 0; i < 32; ++i) {
 181       test[i] = rc4DecryptByte(fState, &fx, &fy, userKey->getChar(i));
 182     }
 183     ok = memcmp(test, passwordPad, 32) == 0;
 184   } else if (encRevision == 3) {
 185     memcpy(test, userKey->getCString(), 32);
 186     for (i = 19; i >= 0; --i) {
 187       for (j = 0; j < keyLength; ++j) {
 188         tmpKey[j] = fileKey[j] ^ i;
 189       }
 190       rc4InitKey(tmpKey, keyLength, fState);
 191       fx = fy = 0;
 192       for (j = 0; j < 32; ++j) {
 193         test[j] = rc4DecryptByte(fState, &fx, &fy, test[j]);
 194       }
 195     }
 196     memcpy(buf, passwordPad, 32);
 197     memcpy(buf + 32, fileID->getCString(), fileID->getLength());
 198     md5(buf, 32 + fileID->getLength(), buf);
 199     ok = memcmp(test, buf, 16) == 0;
 200   } else {
 201     ok = gFalse;
 202   }
 203
 204   gfree(buf);
 205   return ok;
 206 }
 207
 208 //------------------------------------------------------------------------
 209 // RC4-compatible decryption
 210 //------------------------------------------------------------------------
 211
 212 static void rc4InitKey(Guchar *key, int keyLen, Guchar *state) {
 213   Guchar index1, index2;
 214   Guchar t;
 215   int i;
 216
 217   for (i = 0; i < 256; ++i)
 218     state[i] = i;
 219   index1 = index2 = 0;
 220   for (i = 0; i < 256; ++i) {
 221     index2 = (key[index1] + state[i] + index2) % 256;
 222     t = state[i];
 223     state[i] = state[index2];
 224     state[index2] = t;
 225     index1 = (index1 + 1) % keyLen;
 226   }
 227 }
 228
 229 static Guchar rc4DecryptByte(Guchar *state, Guchar *x, Guchar *y, Guchar c) {
 230   Guchar x1, y1, tx, ty;
 231
 232   x1 = *x = (*x + 1) % 256;
 233   y1 = *y = (state[*x] + *y) % 256;
 234   tx = state[x1];
 235   ty = state[y1];
 236   state[x1] = ty;
 237   state[y1] = tx;
 238   return c ^ state[(tx + ty) % 256];
 239 }
 240
 241 //------------------------------------------------------------------------
 242 // MD5 message digest
 243 //------------------------------------------------------------------------
 244
 245 // this works around a bug in older Sun compilers
 246 static inline Gulong rotateLeft(Gulong x, int r) {
 247   x &= 0xffffffff;
 248   return ((x << r) | (x >> (32 - r))) & 0xffffffff;
 249 }
 250
 251 static inline Gulong md5Round1(Gulong a, Gulong b, Gulong c, Gulong d,
 252                                Gulong Xk,  Gulong s, Gulong Ti) {
 253   return b + rotateLeft((a + ((b & c) | (~b & d)) + Xk + Ti), s);
 254 }
 255
 256 static inline Gulong md5Round2(Gulong a, Gulong b, Gulong c, Gulong d,
 257                                Gulong Xk,  Gulong s, Gulong Ti) {
 258   return b + rotateLeft((a + ((b & d) | (c & ~d)) + Xk + Ti), s);
 259 }
 260
 261 static inline Gulong md5Round3(Gulong a, Gulong b, Gulong c, Gulong d,
 262                                Gulong Xk,  Gulong s, Gulong Ti) {
 263   return b + rotateLeft((a + (b ^ c ^ d) + Xk + Ti), s);
 264 }
 265
 266 static inline Gulong md5Round4(Gulong a, Gulong b, Gulong c, Gulong d,
 267                                Gulong Xk,  Gulong s, Gulong Ti) {
 268   return b + rotateLeft((a + (c ^ (b | ~d)) + Xk + Ti), s);
 269 }
 270
 271 static void md5(Guchar *msg, int msgLen, Guchar *digest) {
 272   Gulong x[16];
 273   Gulong a, b, c, d, aa, bb, cc, dd;
 274   int n64;
 275   int i, j, k;
 276
 277   // compute number of 64-byte blocks
 278   // (length + pad byte (0x80) + 8 bytes for length)
 279   n64 = (msgLen + 1 + 8 + 63) / 64;
 280
 281   // initialize a, b, c, d
 282   a = 0x67452301;
 283   b = 0xefcdab89;
 284   c = 0x98badcfe;
 285   d = 0x10325476;
 286
 287   // loop through blocks
 288   k = 0;
 289   for (i = 0; i < n64; ++i) {
 290
 291     // grab a 64-byte block
 292     for (j = 0; j < 16 && k < msgLen - 3; ++j, k += 4)
 293       x[j] = (((((msg[k+3] << 8) + msg[k+2]) << 8) + msg[k+1]) << 8) + msg[k];
 294     if (i == n64 - 1) {
 295       if (k == msgLen - 3)
 296         x[j] = 0x80000000 + (((msg[k+2] << 8) + msg[k+1]) << 8) + msg[k];
 297       else if (k == msgLen - 2)
 298         x[j] = 0x800000 + (msg[k+1] << 8) + msg[k];
 299       else if (k == msgLen - 1)
 300         x[j] = 0x8000 + msg[k];
 301       else
 302         x[j] = 0x80;
 303       ++j;
 304       while (j < 16)
 305         x[j++] = 0;
 306       x[14] = msgLen << 3;
 307     }
 308
 309     // save a, b, c, d
 310     aa = a;
 311     bb = b;
 312     cc = c;
 313     dd = d;
 314
 315     // round 1
 316     a = md5Round1(a, b, c, d, x[0],   7, 0xd76aa478);
 317     d = md5Round1(d, a, b, c, x[1],  12, 0xe8c7b756);
 318     c = md5Round1(c, d, a, b, x[2],  17, 0x242070db);
 319     b = md5Round1(b, c, d, a, x[3],  22, 0xc1bdceee);
 320     a = md5Round1(a, b, c, d, x[4],   7, 0xf57c0faf);
 321     d = md5Round1(d, a, b, c, x[5],  12, 0x4787c62a);
 322     c = md5Round1(c, d, a, b, x[6],  17, 0xa8304613);
 323     b = md5Round1(b, c, d, a, x[7],  22, 0xfd469501);
 324     a = md5Round1(a, b, c, d, x[8],   7, 0x698098d8);
 325     d = md5Round1(d, a, b, c, x[9],  12, 0x8b44f7af);
 326     c = md5Round1(c, d, a, b, x[10], 17, 0xffff5bb1);
 327     b = md5Round1(b, c, d, a, x[11], 22, 0x895cd7be);
 328     a = md5Round1(a, b, c, d, x[12],  7, 0x6b901122);
 329     d = md5Round1(d, a, b, c, x[13], 12, 0xfd987193);
 330     c = md5Round1(c, d, a, b, x[14], 17, 0xa679438e);
 331     b = md5Round1(b, c, d, a, x[15], 22, 0x49b40821);
 332
 333     // round 2
 334     a = md5Round2(a, b, c, d, x[1],   5, 0xf61e2562);
 335     d = md5Round2(d, a, b, c, x[6],   9, 0xc040b340);
 336     c = md5Round2(c, d, a, b, x[11], 14, 0x265e5a51);
 337     b = md5Round2(b, c, d, a, x[0],  20, 0xe9b6c7aa);
 338     a = md5Round2(a, b, c, d, x[5],   5, 0xd62f105d);
 339     d = md5Round2(d, a, b, c, x[10],  9, 0x02441453);
 340     c = md5Round2(c, d, a, b, x[15], 14, 0xd8a1e681);
 341     b = md5Round2(b, c, d, a, x[4],  20, 0xe7d3fbc8);
 342     a = md5Round2(a, b, c, d, x[9],   5, 0x21e1cde6);
 343     d = md5Round2(d, a, b, c, x[14],  9, 0xc33707d6);
 344     c = md5Round2(c, d, a, b, x[3],  14, 0xf4d50d87);
 345     b = md5Round2(b, c, d, a, x[8],  20, 0x455a14ed);
 346     a = md5Round2(a, b, c, d, x[13],  5, 0xa9e3e905);
 347     d = md5Round2(d, a, b, c, x[2],   9, 0xfcefa3f8);
 348     c = md5Round2(c, d, a, b, x[7],  14, 0x676f02d9);
 349     b = md5Round2(b, c, d, a, x[12], 20, 0x8d2a4c8a);
 350
 351     // round 3
 352     a = md5Round3(a, b, c, d, x[5],   4, 0xfffa3942);
 353     d = md5Round3(d, a, b, c, x[8],  11, 0x8771f681);
 354     c = md5Round3(c, d, a, b, x[11], 16, 0x6d9d6122);
 355     b = md5Round3(b, c, d, a, x[14], 23, 0xfde5380c);
 356     a = md5Round3(a, b, c, d, x[1],   4, 0xa4beea44);
 357     d = md5Round3(d, a, b, c, x[4],  11, 0x4bdecfa9);
 358     c = md5Round3(c, d, a, b, x[7],  16, 0xf6bb4b60);
 359     b = md5Round3(b, c, d, a, x[10], 23, 0xbebfbc70);
 360     a = md5Round3(a, b, c, d, x[13],  4, 0x289b7ec6);
 361     d = md5Round3(d, a, b, c, x[0],  11, 0xeaa127fa);
 362     c = md5Round3(c, d, a, b, x[3],  16, 0xd4ef3085);
 363     b = md5Round3(b, c, d, a, x[6],  23, 0x04881d05);
 364     a = md5Round3(a, b, c, d, x[9],   4, 0xd9d4d039);
 365     d = md5Round3(d, a, b, c, x[12], 11, 0xe6db99e5);
 366     c = md5Round3(c, d, a, b, x[15], 16, 0x1fa27cf8);
 367     b = md5Round3(b, c, d, a, x[2],  23, 0xc4ac5665);
 368
 369     // round 4
 370     a = md5Round4(a, b, c, d, x[0],   6, 0xf4292244);
 371     d = md5Round4(d, a, b, c, x[7],  10, 0x432aff97);
 372     c = md5Round4(c, d, a, b, x[14], 15, 0xab9423a7);
 373     b = md5Round4(b, c, d, a, x[5],  21, 0xfc93a039);
 374     a = md5Round4(a, b, c, d, x[12],  6, 0x655b59c3);
 375     d = md5Round4(d, a, b, c, x[3],  10, 0x8f0ccc92);
 376     c = md5Round4(c, d, a, b, x[10], 15, 0xffeff47d);
 377     b = md5Round4(b, c, d, a, x[1],  21, 0x85845dd1);
 378     a = md5Round4(a, b, c, d, x[8],   6, 0x6fa87e4f);
 379     d = md5Round4(d, a, b, c, x[15], 10, 0xfe2ce6e0);
 380     c = md5Round4(c, d, a, b, x[6],  15, 0xa3014314);
 381     b = md5Round4(b, c, d, a, x[13], 21, 0x4e0811a1);
 382     a = md5Round4(a, b, c, d, x[4],   6, 0xf7537e82);
 383     d = md5Round4(d, a, b, c, x[11], 10, 0xbd3af235);
 384     c = md5Round4(c, d, a, b, x[2],  15, 0x2ad7d2bb);
 385     b = md5Round4(b, c, d, a, x[9],  21, 0xeb86d391);
 386
 387     // increment a, b, c, d
 388     a += aa;
 389     b += bb;
 390     c += cc;
 391     d += dd;
 392   }
 393
 394   // break digest into bytes
 395   digest[0] = (Guchar)(a & 0xff);
 396   digest[1] = (Guchar)((a >>= 8) & 0xff);
 397   digest[2] = (Guchar)((a >>= 8) & 0xff);
 398   digest[3] = (Guchar)((a >>= 8) & 0xff);
 399   digest[4] = (Guchar)(b & 0xff);
 400   digest[5] = (Guchar)((b >>= 8) & 0xff);
 401   digest[6] = (Guchar)((b >>= 8) & 0xff);
 402   digest[7] = (Guchar)((b >>= 8) & 0xff);
 403   digest[8] = (Guchar)(c & 0xff);
 404   digest[9] = (Guchar)((c >>= 8) & 0xff);
 405   digest[10] = (Guchar)((c >>= 8) & 0xff);
 406   digest[11] = (Guchar)((c >>= 8) & 0xff);
 407   digest[12] = (Guchar)(d & 0xff);
 408   digest[13] = (Guchar)((d >>= 8) & 0xff);
 409   digest[14] = (Guchar)((d >>= 8) & 0xff);
 410   digest[15] = (Guchar)((d >>= 8) & 0xff);
 411 }