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