Fix uninitialized okeybuf
[pdfium.git] / core / src / fpdfapi / fpdf_parser / fpdf_parser_encrypt.cpp
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4  
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include <time.h>
8 #include "../../../include/fpdfapi/fpdf_parser.h"
9 #include "../../../include/fdrm/fx_crypt.h"
10 const FX_BYTE defpasscode[32] = {
11     0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41,
12     0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08,
13     0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80,
14     0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a
15 };
16 void CalcEncryptKey(CPDF_Dictionary* pEncrypt, FX_LPCBYTE password, FX_DWORD pass_size,
17                     FX_LPBYTE key, int keylen, FX_BOOL bIgnoreMeta, CPDF_Array* pIdArray)
18 {
19     int revision = pEncrypt->GetInteger(FX_BSTRC("R"));
20     FX_BYTE passcode[32];
21     for (FX_DWORD i = 0; i < 32; i ++) {
22         passcode[i] = i < pass_size ? password[i] : defpasscode[i - pass_size];
23     }
24     FX_BYTE md5[100];
25     CRYPT_MD5Start(md5);
26     CRYPT_MD5Update(md5, passcode, 32);
27     CFX_ByteString okey = pEncrypt->GetString(FX_BSTRC("O"));
28     CRYPT_MD5Update(md5, (FX_LPBYTE)(FX_LPCSTR)okey, okey.GetLength());
29     FX_DWORD perm = pEncrypt->GetInteger(FX_BSTRC("P"));
30     CRYPT_MD5Update(md5, (FX_LPBYTE)&perm, 4);
31     if (pIdArray) {
32         CFX_ByteString id = pIdArray->GetString(0);
33         CRYPT_MD5Update(md5, (FX_LPBYTE)(FX_LPCSTR)id, id.GetLength());
34     }
35     if (!bIgnoreMeta && revision >= 3 && !pEncrypt->GetInteger(FX_BSTRC("EncryptMetadata"), 1)) {
36         FX_DWORD tag = (FX_DWORD) - 1;
37         CRYPT_MD5Update(md5, (FX_LPBYTE)&tag, 4);
38     }
39     FX_BYTE digest[16];
40     CRYPT_MD5Finish(md5, digest);
41     FX_DWORD copy_len = keylen;
42     if (copy_len > sizeof(digest)) {
43         copy_len = sizeof(digest);
44     }
45     if (revision >= 3) {
46         for (int i = 0; i < 50; i ++) {
47             CRYPT_MD5Generate(digest, copy_len, digest);
48         }
49     }
50     FXSYS_memset32(key, 0, keylen);
51     FXSYS_memcpy32(key, digest, copy_len);
52 }
53 CPDF_CryptoHandler* CPDF_StandardSecurityHandler::CreateCryptoHandler()
54 {
55     return FX_NEW CPDF_StandardCryptoHandler;
56 }
57 typedef struct _PDF_CRYPTOITEM : public CFX_Object {
58     FX_INT32    m_Cipher;
59     FX_INT32    m_KeyLen;
60     FX_BOOL             m_bChecked;
61     CPDF_StandardCryptoHandler* m_pCryptoHandler;
62 } PDF_CRYPTOITEM;
63 CPDF_StandardSecurityHandler::CPDF_StandardSecurityHandler()
64 {
65     m_Version = 0;
66     m_Revision = 0;
67     m_pParser = NULL;
68     m_pEncryptDict = NULL;
69     m_bOwner = FALSE;
70     m_Permissions = 0;
71     m_Cipher = FXCIPHER_NONE;
72     m_KeyLen = 0;
73 }
74 CPDF_StandardSecurityHandler::~CPDF_StandardSecurityHandler()
75 {
76 }
77 FX_BOOL CPDF_StandardSecurityHandler::OnInit(CPDF_Parser* pParser, CPDF_Dictionary* pEncryptDict)
78 {
79     m_pParser = pParser;
80     if (!LoadDict(pEncryptDict)) {
81         return FALSE;
82     }
83     if (m_Cipher == FXCIPHER_NONE) {
84         return TRUE;
85     }
86     return CheckSecurity(m_KeyLen);
87 }
88 FX_BOOL CPDF_StandardSecurityHandler::CheckSecurity(FX_INT32 key_len)
89 {
90     CFX_ByteString password = m_pParser->GetPassword();
91     if (CheckPassword(password, password.GetLength(), TRUE, m_EncryptKey, key_len)) {
92         if (password.IsEmpty()) {
93             if (!CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey, key_len)) {
94                 return FALSE;
95             }
96         }
97         m_bOwner = TRUE;
98         return TRUE;
99     }
100     return CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey, key_len);
101 }
102 FX_DWORD CPDF_StandardSecurityHandler::GetPermissions()
103 {
104     return m_Permissions;
105 }
106 static FX_BOOL _LoadCryptInfo(CPDF_Dictionary* pEncryptDict, FX_BSTR name, int& cipher, int& keylen)
107 {
108     int Version = pEncryptDict->GetInteger(FX_BSTRC("V"));
109     int Revision = pEncryptDict->GetInteger(FX_BSTRC("R"));
110     cipher = FXCIPHER_RC4;
111     keylen = 0;
112     if (Version >= 4) {
113         CPDF_Dictionary* pCryptFilters = pEncryptDict->GetDict(FX_BSTRC("CF"));
114         if (pCryptFilters == NULL) {
115             return FALSE;
116         }
117         if (name == FX_BSTRC("Identity")) {
118             cipher = FXCIPHER_NONE;
119         } else {
120             CPDF_Dictionary* pDefFilter = pCryptFilters->GetDict(name);
121             if (pDefFilter == NULL) {
122                 return FALSE;
123             }
124             int nKeyBits = 0;
125             if (Version == 4) {
126                 nKeyBits = pDefFilter->GetInteger(FX_BSTRC("Length"), 0);
127                 if (nKeyBits == 0) {
128                     nKeyBits = pEncryptDict->GetInteger(FX_BSTRC("Length"), 128);
129                 }
130             } else {
131                 nKeyBits = pEncryptDict->GetInteger(FX_BSTRC("Length"), 256);
132             }
133             if (nKeyBits < 40) {
134                 nKeyBits *= 8;
135             }
136             keylen = nKeyBits / 8;
137             CFX_ByteString cipher_name = pDefFilter->GetString(FX_BSTRC("CFM"));
138             if (cipher_name == FX_BSTRC("AESV2") || cipher_name == FX_BSTRC("AESV3")) {
139                 cipher = FXCIPHER_AES;
140             }
141         }
142     } else {
143         keylen = Version > 1 ? pEncryptDict->GetInteger(FX_BSTRC("Length"), 40) / 8 : 5;
144     }
145     if (keylen > 32 || keylen < 0) {
146         return FALSE;
147     }
148     return TRUE;
149 }
150 FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict)
151 {
152     m_pEncryptDict = pEncryptDict;
153     m_bOwner = FALSE;
154     m_Version = pEncryptDict->GetInteger(FX_BSTRC("V"));
155     m_Revision = pEncryptDict->GetInteger(FX_BSTRC("R"));
156     m_Permissions = pEncryptDict->GetInteger(FX_BSTRC("P"), -1);
157     if (m_Version < 4) {
158         return _LoadCryptInfo(pEncryptDict, CFX_ByteString(), m_Cipher, m_KeyLen);
159     }
160     CFX_ByteString stmf_name = pEncryptDict->GetString(FX_BSTRC("StmF"));
161     CFX_ByteString strf_name = pEncryptDict->GetString(FX_BSTRC("StrF"));
162     if (stmf_name != strf_name) {
163         return FALSE;
164     }
165     if (!_LoadCryptInfo(pEncryptDict, strf_name, m_Cipher, m_KeyLen)) {
166         return FALSE;
167     }
168     return TRUE;
169 }
170 FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict, FX_DWORD type, int& cipher, int& key_len)
171 {
172     m_pEncryptDict = pEncryptDict;
173     m_bOwner = FALSE;
174     m_Version = pEncryptDict->GetInteger(FX_BSTRC("V"));
175     m_Revision = pEncryptDict->GetInteger(FX_BSTRC("R"));
176     m_Permissions = pEncryptDict->GetInteger(FX_BSTRC("P"), -1);
177     CFX_ByteString strf_name, stmf_name;
178     if (m_Version >= 4) {
179         stmf_name = pEncryptDict->GetString(FX_BSTRC("StmF"));
180         strf_name = pEncryptDict->GetString(FX_BSTRC("StrF"));
181         if (stmf_name != strf_name) {
182             return FALSE;
183         }
184     }
185     if (!_LoadCryptInfo(pEncryptDict, strf_name, cipher, key_len)) {
186         return FALSE;
187     }
188     m_Cipher = cipher;
189     m_KeyLen = key_len;
190     return TRUE;
191     return TRUE;
192 }
193 FX_BOOL CPDF_StandardSecurityHandler::GetCryptInfo(int& cipher, FX_LPCBYTE& buffer, int& keylen)
194 {
195     cipher = m_Cipher;
196     buffer = m_EncryptKey;
197     keylen = m_KeyLen;
198     return TRUE;
199 }
200 #define FX_GET_32WORD(n,b,i)                                                            \
201     {                                                                                                           \
202         (n) = (FX_DWORD)(( (FX_UINT64) (b)[(i)] << 24 )                 \
203                          | ( (FX_UINT64) (b)[(i) + 1] << 16 )                                   \
204                          | ( (FX_UINT64) (b)[(i) + 2] <<  8 )                                   \
205                          | ( (FX_UINT64) (b)[(i) + 3]       ));                                 \
206     }
207 int BigOrder64BitsMod3(FX_LPBYTE data)
208 {
209     FX_UINT64 ret = 0;
210     for (int i = 0; i < 4; ++i) {
211         FX_DWORD value;
212         FX_GET_32WORD(value, data, 4 * i);
213         ret <<= 32;
214         ret |= value;
215         ret %= 3;
216     }
217     return (int)ret;
218 }
219 void Revision6_Hash(FX_LPCBYTE password, FX_DWORD size, FX_LPCBYTE salt, FX_LPCBYTE vector, FX_LPBYTE hash)
220 {
221     int iBlockSize = 32;
222     FX_BYTE sha[128];
223     CRYPT_SHA256Start(sha);
224     CRYPT_SHA256Update(sha, password, size);
225     CRYPT_SHA256Update(sha, salt, 8);
226     if (vector) {
227         CRYPT_SHA256Update(sha, vector, 48);
228     }
229     FX_BYTE digest[32];
230     CRYPT_SHA256Finish(sha, digest);
231     CFX_ByteTextBuf buf;
232     FX_LPBYTE input = digest;
233     FX_LPBYTE key = input;
234     FX_LPBYTE iv = input + 16;
235     FX_LPBYTE E = buf.GetBuffer();
236     int iBufLen = buf.GetLength();
237     CFX_ByteTextBuf interDigest;
238     int i = 0;
239     FX_LPBYTE aes = FX_Alloc(FX_BYTE, 2048);
240     while (i < 64 || i < E[iBufLen - 1]  + 32) {
241         int iRoundSize = size + iBlockSize;
242         if (vector) {
243             iRoundSize += 48;
244         }
245         iBufLen = iRoundSize * 64;
246         buf.EstimateSize(iBufLen);
247         E = buf.GetBuffer();
248         CFX_ByteTextBuf content;
249         for (int j = 0; j < 64; ++j) {
250             content.AppendBlock(password, size);
251             content.AppendBlock(input, iBlockSize);
252             if (vector) {
253                 content.AppendBlock(vector, 48);
254             }
255         }
256         CRYPT_AESSetKey(aes, 16, key, 16, TRUE);
257         CRYPT_AESSetIV(aes, iv);
258         CRYPT_AESEncrypt(aes, E, content.GetBuffer(), iBufLen);
259         int iHash = 0;
260         switch (BigOrder64BitsMod3(E)) {
261             case 0:
262                 iHash = 0;
263                 iBlockSize = 32;
264                 break;
265             case 1:
266                 iHash = 1;
267                 iBlockSize = 48;
268                 break;
269             default:
270                 iHash = 2;
271                 iBlockSize = 64;
272                 break;
273         }
274         interDigest.EstimateSize(iBlockSize);
275         input = interDigest.GetBuffer();
276         if (iHash == 0) {
277             CRYPT_SHA256Generate(E, iBufLen, input);
278         } else if (iHash == 1) {
279             CRYPT_SHA384Generate(E, iBufLen, input);
280         } else if (iHash == 2) {
281             CRYPT_SHA512Generate(E, iBufLen, input);
282         }
283         key = input;
284         iv = input + 16;
285         ++i;
286     }
287     FX_Free(aes);
288     if (hash) {
289         FXSYS_memcpy32(hash, input, 32);
290     }
291 }
292 FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(FX_LPCBYTE password, FX_DWORD size,
293         FX_BOOL bOwner, FX_LPBYTE key)
294 {
295     CFX_ByteString okey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("O")) : CFX_ByteString();
296     if (okey.GetLength() < 48) {
297         return FALSE;
298     }
299     CFX_ByteString ukey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("U")) : CFX_ByteString();
300     if (ukey.GetLength() < 48) {
301         return FALSE;
302     }
303     FX_LPCBYTE pkey = bOwner ? (FX_LPCBYTE)okey : (FX_LPCBYTE)ukey;
304     FX_BYTE sha[128];
305     FX_BYTE digest[32];
306     if (m_Revision >= 6) {
307         Revision6_Hash(password, size, (FX_LPCBYTE)pkey + 32, (bOwner ? (FX_LPCBYTE)ukey : NULL), digest);
308     } else {
309         CRYPT_SHA256Start(sha);
310         CRYPT_SHA256Update(sha, password, size);
311         CRYPT_SHA256Update(sha, pkey + 32, 8);
312         if (bOwner) {
313             CRYPT_SHA256Update(sha, ukey, 48);
314         }
315         CRYPT_SHA256Finish(sha, digest);
316     }
317     if (FXSYS_memcmp32(digest, pkey, 32) != 0) {
318         return FALSE;
319     }
320     if (key == NULL) {
321         return TRUE;
322     }
323     if (m_Revision >= 6) {
324         Revision6_Hash(password, size, (FX_LPCBYTE)pkey + 40, (bOwner ? (FX_LPCBYTE)ukey : NULL), digest);
325     } else {
326         CRYPT_SHA256Start(sha);
327         CRYPT_SHA256Update(sha, password, size);
328         CRYPT_SHA256Update(sha, pkey + 40, 8);
329         if (bOwner) {
330             CRYPT_SHA256Update(sha, ukey, 48);
331         }
332         CRYPT_SHA256Finish(sha, digest);
333     }
334     CFX_ByteString ekey = m_pEncryptDict ? m_pEncryptDict->GetString(bOwner ? FX_BSTRC("OE") : FX_BSTRC("UE")) : CFX_ByteString();
335     if (ekey.GetLength() < 32) {
336         return FALSE;
337     }
338     FX_BYTE* aes = FX_Alloc(FX_BYTE, 2048);
339     CRYPT_AESSetKey(aes, 16, digest, 32, FALSE);
340     FX_BYTE iv[16];
341     FXSYS_memset32(iv, 0, 16);
342     CRYPT_AESSetIV(aes, iv);
343     CRYPT_AESDecrypt(aes, key, ekey, 32);
344     CRYPT_AESSetKey(aes, 16, key, 32, FALSE);
345     CRYPT_AESSetIV(aes, iv);
346     CFX_ByteString perms = m_pEncryptDict->GetString(FX_BSTRC("Perms"));
347     if (perms.IsEmpty()) {
348         return FALSE;
349     }
350     FX_BYTE perms_buf[16];
351     FXSYS_memset32(perms_buf, 0, sizeof(perms_buf));
352     FX_DWORD copy_len = sizeof(perms_buf);
353     if (copy_len > (FX_DWORD)perms.GetLength()) {
354         copy_len = perms.GetLength();
355     }
356     FXSYS_memcpy32(perms_buf, (FX_LPCBYTE)perms, copy_len);
357     FX_BYTE buf[16];
358     CRYPT_AESDecrypt(aes, buf, perms_buf, 16);
359     FX_Free(aes);
360     if (buf[9] != 'a' || buf[10] != 'd' || buf[11] != 'b') {
361         return FALSE;
362     }
363     if (FXDWORD_GET_LSBFIRST(buf) != m_Permissions) {
364         return FALSE;
365     }
366     if ((buf[8] == 'T' && !IsMetadataEncrypted()) || (buf[8] == 'F' && IsMetadataEncrypted())) {
367         return FALSE;
368     }
369     return TRUE;
370 }
371 int CPDF_StandardSecurityHandler::CheckPassword(FX_LPCBYTE password, FX_DWORD pass_size, FX_BOOL bOwner, FX_LPBYTE key)
372 {
373     return CheckPassword(password, pass_size, bOwner, key, m_KeyLen);
374 }
375 int CPDF_StandardSecurityHandler::CheckPassword(FX_LPCBYTE password, FX_DWORD size, FX_BOOL bOwner, FX_LPBYTE key, FX_INT32 key_len)
376 {
377     if (m_Revision >= 5) {
378         return AES256_CheckPassword(password, size, bOwner, key);
379     }
380     FX_BYTE keybuf[32];
381     if (key == NULL) {
382         key = keybuf;
383     }
384     if (bOwner) {
385         return CheckOwnerPassword(password, size, key, key_len);
386     }
387     return CheckUserPassword(password, size, FALSE, key, key_len) || CheckUserPassword(password, size, TRUE, key, key_len);
388 }
389 FX_BOOL CPDF_StandardSecurityHandler::CheckUserPassword(FX_LPCBYTE password, FX_DWORD pass_size,
390         FX_BOOL bIgnoreEncryptMeta, FX_LPBYTE key, FX_INT32 key_len)
391 {
392     CalcEncryptKey(m_pEncryptDict, password, pass_size, key, key_len, bIgnoreEncryptMeta,
393                    m_pParser->GetIDArray());
394     CFX_ByteString ukey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("U")) : CFX_ByteString();
395     if (ukey.GetLength() < 16) {
396         return FALSE;
397     }
398     FX_BYTE ukeybuf[32];
399     if (m_Revision == 2) {
400         FXSYS_memcpy32(ukeybuf, defpasscode, 32);
401         CRYPT_ArcFourCryptBlock(ukeybuf, 32, key, key_len);
402     } else {
403         FX_BYTE test[32], tmpkey[32];
404         FX_DWORD copy_len = sizeof(test);
405         if (copy_len > (FX_DWORD)ukey.GetLength()) {
406             copy_len = ukey.GetLength();
407         }
408         FXSYS_memset32(test, 0, sizeof(test));
409         FXSYS_memset32(tmpkey, 0, sizeof(tmpkey));
410         FXSYS_memcpy32(test, (FX_LPCSTR)ukey, copy_len);
411         for (int i = 19; i >= 0; i --) {
412             for (int j = 0; j < key_len; j ++) {
413                 tmpkey[j] = key[j] ^ i;
414             }
415             CRYPT_ArcFourCryptBlock(test, 32, tmpkey, key_len);
416         }
417         FX_BYTE md5[100];
418         CRYPT_MD5Start(md5);
419         CRYPT_MD5Update(md5, defpasscode, 32);
420         CPDF_Array* pIdArray = m_pParser->GetIDArray();
421         if (pIdArray) {
422             CFX_ByteString id = pIdArray->GetString(0);
423             CRYPT_MD5Update(md5, (FX_LPBYTE)(FX_LPCSTR)id, id.GetLength());
424         }
425         CRYPT_MD5Finish(md5, ukeybuf);
426         return FXSYS_memcmp32(test, ukeybuf, 16) == 0;
427     }
428     if (FXSYS_memcmp32((FX_LPVOID)(FX_LPCSTR)ukey, ukeybuf, 16) == 0) {
429         return TRUE;
430     }
431     return FALSE;
432 }
433 CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(FX_LPCBYTE owner_pass, FX_DWORD pass_size)
434 {
435     return GetUserPassword(owner_pass, pass_size, m_KeyLen);
436 }
437 CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(FX_LPCBYTE owner_pass, FX_DWORD pass_size, FX_INT32 key_len)
438 {
439     CFX_ByteString okey = m_pEncryptDict->GetString(FX_BSTRC("O"));
440     FX_BYTE passcode[32];
441     FX_DWORD i;
442     for (i = 0; i < 32; i ++) {
443         passcode[i] = i < pass_size ? owner_pass[i] : defpasscode[i - pass_size];
444     }
445     FX_BYTE digest[16];
446     CRYPT_MD5Generate(passcode, 32, digest);
447     if (m_Revision >= 3) {
448         for (int i = 0; i < 50; i ++) {
449             CRYPT_MD5Generate(digest, 16, digest);
450         }
451     }
452     FX_BYTE enckey[32];
453     FXSYS_memset32(enckey, 0, sizeof(enckey));
454     FX_DWORD copy_len = key_len;
455     if (copy_len > sizeof(digest)) {
456         copy_len = sizeof(digest);
457     }
458     FXSYS_memcpy32(enckey, digest, copy_len);
459     int okeylen = okey.GetLength();
460     if (okeylen > 32) {
461         okeylen = 32;
462     }
463     FX_BYTE okeybuf[64];
464     FXSYS_memset32(okeybuf, 0, sizeof(okeybuf));
465     FXSYS_memcpy32(okeybuf, (FX_LPCSTR)okey, okeylen);
466     if (m_Revision == 2) {
467         CRYPT_ArcFourCryptBlock(okeybuf, okeylen, enckey, key_len);
468     } else {
469         for (int i = 19; i >= 0; i --) {
470             FX_BYTE tempkey[32];
471             FXSYS_memset32(tempkey, 0, sizeof(tempkey));
472             for (int j = 0; j < m_KeyLen; j ++) {
473                 tempkey[j] = enckey[j] ^ i;
474             }
475             CRYPT_ArcFourCryptBlock(okeybuf, okeylen, tempkey, key_len);
476         }
477     }
478     int len = 32;
479     while (len && defpasscode[len - 1] == okeybuf[len - 1]) {
480         len --;
481     }
482     return CFX_ByteString(okeybuf, len);
483 }
484 FX_BOOL CPDF_StandardSecurityHandler::CheckOwnerPassword(FX_LPCBYTE password, FX_DWORD pass_size,
485         FX_LPBYTE key, FX_INT32 key_len)
486 {
487     CFX_ByteString user_pass = GetUserPassword(password, pass_size, key_len);
488     if (CheckUserPassword(user_pass, user_pass.GetLength(), FALSE, key, key_len)) {
489         return TRUE;
490     }
491     return CheckUserPassword(user_pass, user_pass.GetLength(), TRUE, key, key_len);
492 }
493 FX_BOOL CPDF_StandardSecurityHandler::IsMetadataEncrypted()
494 {
495     return m_pEncryptDict->GetBoolean(FX_BSTRC("EncryptMetadata"), TRUE);
496 }
497 CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler()
498 {
499     return FX_NEW CPDF_StandardSecurityHandler;
500 }
501 void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray,
502         FX_LPCBYTE user_pass, FX_DWORD user_size,
503         FX_LPCBYTE owner_pass, FX_DWORD owner_size, FX_BOOL bDefault, FX_DWORD type)
504 {
505     int cipher = 0, key_len = 0;
506     if (!LoadDict(pEncryptDict, type, cipher, key_len)) {
507         return;
508     }
509     if (bDefault && (owner_pass == NULL || owner_size == 0)) {
510         owner_pass = user_pass;
511         owner_size = user_size;
512     }
513     if (m_Revision >= 5) {
514         int t = (int)time(NULL);
515         FX_BYTE sha[128];
516         CRYPT_SHA256Start(sha);
517         CRYPT_SHA256Update(sha, (FX_BYTE*)&t, sizeof t);
518         CRYPT_SHA256Update(sha, m_EncryptKey, 32);
519         CRYPT_SHA256Update(sha, (FX_BYTE*)"there", 5);
520         CRYPT_SHA256Finish(sha, m_EncryptKey);
521         AES256_SetPassword(pEncryptDict, user_pass, user_size, FALSE, m_EncryptKey);
522         if (bDefault) {
523             AES256_SetPassword(pEncryptDict, owner_pass, owner_size, TRUE, m_EncryptKey);
524             AES256_SetPerms(pEncryptDict, m_Permissions, pEncryptDict->GetBoolean(FX_BSTRC("EncryptMetadata"), TRUE), m_EncryptKey);
525         }
526         return;
527     }
528     if (bDefault) {
529         FX_BYTE passcode[32];
530         FX_DWORD i;
531         for (i = 0; i < 32; i ++) {
532             passcode[i] = i < owner_size ? owner_pass[i] : defpasscode[i - owner_size];
533         }
534         FX_BYTE digest[16];
535         CRYPT_MD5Generate(passcode, 32, digest);
536         if (m_Revision >= 3) {
537             for (int i = 0; i < 50; i ++) {
538                 CRYPT_MD5Generate(digest, 16, digest);
539             }
540         }
541         FX_BYTE enckey[32];
542         FXSYS_memcpy32(enckey, digest, key_len);
543         for (i = 0; i < 32; i ++) {
544             passcode[i] = i < user_size ? user_pass[i] : defpasscode[i - user_size];
545         }
546         CRYPT_ArcFourCryptBlock(passcode, 32, enckey, key_len);
547         FX_BYTE tempkey[32];
548         if (m_Revision >= 3) {
549             for (i = 1; i <= 19; i ++) {
550                 for (int j = 0; j < key_len; j ++) {
551                     tempkey[j] = enckey[j] ^ (FX_BYTE)i;
552                 }
553                 CRYPT_ArcFourCryptBlock(passcode, 32, tempkey, key_len);
554             }
555         }
556         pEncryptDict->SetAtString(FX_BSTRC("O"), CFX_ByteString(passcode, 32));
557     }
558     CalcEncryptKey(m_pEncryptDict, (FX_LPBYTE)user_pass, user_size, m_EncryptKey, key_len, FALSE, pIdArray);
559     if (m_Revision < 3) {
560         FX_BYTE tempbuf[32];
561         FXSYS_memcpy32(tempbuf, defpasscode, 32);
562         CRYPT_ArcFourCryptBlock(tempbuf, 32, m_EncryptKey, key_len);
563         pEncryptDict->SetAtString(FX_BSTRC("U"), CFX_ByteString(tempbuf, 32));
564     } else {
565         FX_BYTE md5[100];
566         CRYPT_MD5Start(md5);
567         CRYPT_MD5Update(md5, defpasscode, 32);
568         if (pIdArray) {
569             CFX_ByteString id = pIdArray->GetString(0);
570             CRYPT_MD5Update(md5, (FX_LPBYTE)(FX_LPCSTR)id, id.GetLength());
571         }
572         FX_BYTE digest[32];
573         CRYPT_MD5Finish(md5, digest);
574         CRYPT_ArcFourCryptBlock(digest, 16, m_EncryptKey, key_len);
575         FX_BYTE tempkey[32];
576         for (int i = 1; i <= 19; i ++) {
577             for (int j = 0; j < key_len; j ++) {
578                 tempkey[j] = m_EncryptKey[j] ^ (FX_BYTE)i;
579             }
580             CRYPT_ArcFourCryptBlock(digest, 16, tempkey, key_len);
581         }
582         CRYPT_MD5Generate(digest, 16, digest + 16);
583         pEncryptDict->SetAtString(FX_BSTRC("U"), CFX_ByteString(digest, 32));
584     }
585 }
586 void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray,
587         FX_LPCBYTE user_pass, FX_DWORD user_size,
588         FX_LPCBYTE owner_pass, FX_DWORD owner_size, FX_DWORD type)
589 {
590     OnCreate(pEncryptDict, pIdArray, user_pass, user_size, owner_pass, owner_size, TRUE, type);
591 }
592 void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray, FX_LPCBYTE user_pass, FX_DWORD user_size, FX_DWORD type)
593 {
594     OnCreate(pEncryptDict, pIdArray, user_pass, user_size, NULL, 0, FALSE, type);
595 }
596 void CPDF_StandardSecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict, FX_LPCBYTE password, FX_DWORD size, FX_BOOL bOwner, FX_LPCBYTE key)
597 {
598     FX_BYTE sha[128];
599     CRYPT_SHA1Start(sha);
600     CRYPT_SHA1Update(sha, key, 32);
601     CRYPT_SHA1Update(sha, (FX_BYTE*)"hello", 5);
602     FX_BYTE digest[20];
603     CRYPT_SHA1Finish(sha, digest);
604     CFX_ByteString ukey = pEncryptDict->GetString(FX_BSTRC("U"));
605     FX_BYTE digest1[48];
606     if (m_Revision >= 6) {
607         Revision6_Hash(password, size, digest, (bOwner ? (FX_LPCBYTE)ukey : NULL), digest1);
608     } else {
609         CRYPT_SHA256Start(sha);
610         CRYPT_SHA256Update(sha, password, size);
611         CRYPT_SHA256Update(sha, digest, 8);
612         if (bOwner) {
613             CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
614         }
615         CRYPT_SHA256Finish(sha, digest1);
616     }
617     FXSYS_memcpy32(digest1 + 32, digest, 16);
618     pEncryptDict->SetAtString(bOwner ? FX_BSTRC("O") : FX_BSTRC("U"), CFX_ByteString(digest1, 48));
619     if (m_Revision >= 6) {
620         Revision6_Hash(password, size, digest + 8, (bOwner ? (FX_LPCBYTE)ukey : NULL), digest1);
621     } else {
622         CRYPT_SHA256Start(sha);
623         CRYPT_SHA256Update(sha, password, size);
624         CRYPT_SHA256Update(sha, digest + 8, 8);
625         if (bOwner) {
626             CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
627         }
628         CRYPT_SHA256Finish(sha, digest1);
629     }
630     FX_BYTE* aes = FX_Alloc(FX_BYTE, 2048);
631     CRYPT_AESSetKey(aes, 16, digest1, 32, TRUE);
632     FX_BYTE iv[16];
633     FXSYS_memset32(iv, 0, 16);
634     CRYPT_AESSetIV(aes, iv);
635     CRYPT_AESEncrypt(aes, digest1, key, 32);
636     FX_Free(aes);
637     pEncryptDict->SetAtString(bOwner ? FX_BSTRC("OE") : FX_BSTRC("UE"), CFX_ByteString(digest1, 32));
638 }
639 void CPDF_StandardSecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict, FX_DWORD permissions,
640         FX_BOOL bEncryptMetadata, FX_LPCBYTE key)
641 {
642     FX_BYTE buf[16];
643     buf[0] = (FX_BYTE)permissions;
644     buf[1] = (FX_BYTE)(permissions >> 8);
645     buf[2] = (FX_BYTE)(permissions >> 16);
646     buf[3] = (FX_BYTE)(permissions >> 24);
647     buf[4] = 0xff;
648     buf[5] = 0xff;
649     buf[6] = 0xff;
650     buf[7] = 0xff;
651     buf[8] = bEncryptMetadata ? 'T' : 'F';
652     buf[9] = 'a';
653     buf[10] = 'd';
654     buf[11] = 'b';
655     FX_BYTE* aes = FX_Alloc(FX_BYTE, 2048);
656     CRYPT_AESSetKey(aes, 16, key, 32, TRUE);
657     FX_BYTE iv[16], buf1[16];
658     FXSYS_memset32(iv, 0, 16);
659     CRYPT_AESSetIV(aes, iv);
660     CRYPT_AESEncrypt(aes, buf1, buf, 16);
661     FX_Free(aes);
662     pEncryptDict->SetAtString(FX_BSTRC("Perms"), CFX_ByteString(buf1, 16));
663 }
664 void CPDF_StandardCryptoHandler::CryptBlock(FX_BOOL bEncrypt, FX_DWORD objnum, FX_DWORD gennum, FX_LPCBYTE src_buf, FX_DWORD src_size,
665         FX_LPBYTE dest_buf, FX_DWORD& dest_size)
666 {
667     if (m_Cipher == FXCIPHER_NONE) {
668         FXSYS_memcpy32(dest_buf, src_buf, src_size);
669         return;
670     }
671     FX_BYTE realkey[16];
672     int realkeylen = 16;
673     if (m_Cipher != FXCIPHER_AES || m_KeyLen != 32) {
674         FX_BYTE key1[32];
675         FXSYS_memcpy32(key1, m_EncryptKey, m_KeyLen);
676         key1[m_KeyLen + 0] = (FX_BYTE)objnum;
677         key1[m_KeyLen + 1] = (FX_BYTE)(objnum >> 8);
678         key1[m_KeyLen + 2] = (FX_BYTE)(objnum >> 16);
679         key1[m_KeyLen + 3] = (FX_BYTE)gennum;
680         key1[m_KeyLen + 4] = (FX_BYTE)(gennum >> 8);
681         FXSYS_memcpy32(key1 + m_KeyLen, &objnum, 3);
682         FXSYS_memcpy32(key1 + m_KeyLen + 3, &gennum, 2);
683         if (m_Cipher == FXCIPHER_AES) {
684             FXSYS_memcpy32(key1 + m_KeyLen + 5, "sAlT", 4);
685         }
686         CRYPT_MD5Generate(key1, m_Cipher == FXCIPHER_AES ? m_KeyLen + 9 : m_KeyLen + 5, realkey);
687         realkeylen = m_KeyLen + 5;
688         if (realkeylen > 16) {
689             realkeylen = 16;
690         }
691     }
692     if (m_Cipher == FXCIPHER_AES) {
693         CRYPT_AESSetKey(m_pAESContext, 16, m_KeyLen == 32 ? m_EncryptKey : realkey, m_KeyLen, bEncrypt);
694         if (bEncrypt) {
695             FX_BYTE iv[16];
696             for (int i = 0; i < 16; i ++) {
697                 iv[i] = (FX_BYTE)rand();
698             }
699             CRYPT_AESSetIV(m_pAESContext, iv);
700             FXSYS_memcpy32(dest_buf, iv, 16);
701             int nblocks = src_size / 16;
702             CRYPT_AESEncrypt(m_pAESContext, dest_buf + 16, src_buf, nblocks * 16);
703             FX_BYTE padding[16];
704             FXSYS_memcpy32(padding, src_buf + nblocks * 16, src_size % 16);
705             FXSYS_memset8(padding + src_size % 16, 16 - src_size % 16, 16 - src_size % 16);
706             CRYPT_AESEncrypt(m_pAESContext, dest_buf + nblocks * 16 + 16, padding, 16);
707             dest_size = 32 + nblocks * 16;
708         } else {
709             CRYPT_AESSetIV(m_pAESContext, src_buf);
710             CRYPT_AESDecrypt(m_pAESContext, dest_buf, src_buf + 16, src_size - 16);
711             dest_size = src_size - 16;
712             dest_size -= dest_buf[dest_size - 1];
713         }
714     } else {
715         ASSERT(dest_size == src_size);
716         if (dest_buf != src_buf) {
717             FXSYS_memcpy32(dest_buf, src_buf, src_size);
718         }
719         CRYPT_ArcFourCryptBlock(dest_buf, dest_size, realkey, realkeylen);
720     }
721 }
722 typedef struct _AESCryptContext {
723     FX_BYTE             m_Context[2048];
724     FX_BOOL             m_bIV;
725     FX_BYTE             m_Block[16];
726     FX_DWORD    m_BlockOffset;
727 } AESCryptContext;
728 FX_LPVOID CPDF_StandardCryptoHandler::CryptStart(FX_DWORD objnum, FX_DWORD gennum, FX_BOOL bEncrypt)
729 {
730     if (m_Cipher == FXCIPHER_NONE) {
731         return this;
732     }
733     if (m_Cipher == FXCIPHER_AES && m_KeyLen == 32) {
734         AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1);
735         pContext->m_bIV = TRUE;
736         pContext->m_BlockOffset = 0;
737         CRYPT_AESSetKey(pContext->m_Context, 16, m_EncryptKey, 32, bEncrypt);
738         if (bEncrypt) {
739             for (int i = 0; i < 16; i ++) {
740                 pContext->m_Block[i] = (FX_BYTE)rand();
741             }
742             CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block);
743         }
744         return pContext;
745     }
746     FX_BYTE key1[48];
747     FXSYS_memcpy32(key1, m_EncryptKey, m_KeyLen);
748     FXSYS_memcpy32(key1 + m_KeyLen, &objnum, 3);
749     FXSYS_memcpy32(key1 + m_KeyLen + 3, &gennum, 2);
750     if (m_Cipher == FXCIPHER_AES) {
751         FXSYS_memcpy32(key1 + m_KeyLen + 5, "sAlT", 4);
752     }
753     FX_BYTE realkey[16];
754     CRYPT_MD5Generate(key1, m_Cipher == FXCIPHER_AES ? m_KeyLen + 9 : m_KeyLen + 5, realkey);
755     int realkeylen = m_KeyLen + 5;
756     if (realkeylen > 16) {
757         realkeylen = 16;
758     }
759     if (m_Cipher == FXCIPHER_AES) {
760         AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1);
761         pContext->m_bIV = TRUE;
762         pContext->m_BlockOffset = 0;
763         CRYPT_AESSetKey(pContext->m_Context, 16, realkey, 16, bEncrypt);
764         if (bEncrypt) {
765             for (int i = 0; i < 16; i ++) {
766                 pContext->m_Block[i] = (FX_BYTE)rand();
767             }
768             CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block);
769         }
770         return pContext;
771     }
772     void* pContext = FX_Alloc(FX_BYTE, 1040);
773     CRYPT_ArcFourSetup(pContext, realkey, realkeylen);
774     return pContext;
775 }
776 FX_BOOL CPDF_StandardCryptoHandler::CryptStream(FX_LPVOID context, FX_LPCBYTE src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt)
777 {
778     if (!context) {
779         return FALSE;
780     }
781     if (m_Cipher == FXCIPHER_NONE) {
782         dest_buf.AppendBlock(src_buf, src_size);
783         return TRUE;
784     }
785     if (m_Cipher == FXCIPHER_RC4) {
786         int old_size = dest_buf.GetSize();
787         dest_buf.AppendBlock(src_buf, src_size);
788         CRYPT_ArcFourCrypt(context, dest_buf.GetBuffer() + old_size, src_size);
789         return TRUE;
790     }
791     AESCryptContext* pContext = (AESCryptContext*)context;
792     if (pContext->m_bIV && bEncrypt) {
793         dest_buf.AppendBlock(pContext->m_Block, 16);
794         pContext->m_bIV = FALSE;
795     }
796     FX_DWORD src_off = 0;
797     FX_DWORD src_left = src_size;
798     while (1) {
799         FX_DWORD copy_size = 16 - pContext->m_BlockOffset;
800         if (copy_size > src_left) {
801             copy_size = src_left;
802         }
803         FXSYS_memcpy32(pContext->m_Block + pContext->m_BlockOffset, src_buf + src_off, copy_size);
804         src_off += copy_size;
805         src_left -= copy_size;
806         pContext->m_BlockOffset += copy_size;
807         if (pContext->m_BlockOffset == 16) {
808             if (!bEncrypt && pContext->m_bIV) {
809                 CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block);
810                 pContext->m_bIV = FALSE;
811                 pContext->m_BlockOffset = 0;
812             } else if (src_off < src_size) {
813                 FX_BYTE block_buf[16];
814                 if (bEncrypt) {
815                     CRYPT_AESEncrypt(pContext->m_Context, block_buf, pContext->m_Block, 16);
816                 } else {
817                     CRYPT_AESDecrypt(pContext->m_Context, block_buf, pContext->m_Block, 16);
818                 }
819                 dest_buf.AppendBlock(block_buf, 16);
820                 pContext->m_BlockOffset = 0;
821             }
822         }
823         if (!src_left) {
824             break;
825         }
826     }
827     return TRUE;
828 }
829 FX_BOOL CPDF_StandardCryptoHandler::CryptFinish(FX_LPVOID context, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt)
830 {
831     if (!context) {
832         return FALSE;
833     }
834     if (m_Cipher == FXCIPHER_NONE) {
835         return TRUE;
836     }
837     if (m_Cipher == FXCIPHER_RC4) {
838         FX_Free(context);
839         return TRUE;
840     }
841     AESCryptContext* pContext = (AESCryptContext*)context;
842     if (bEncrypt) {
843         FX_BYTE block_buf[16];
844         if (pContext->m_BlockOffset == 16) {
845             CRYPT_AESEncrypt(pContext->m_Context, block_buf, pContext->m_Block, 16);
846             dest_buf.AppendBlock(block_buf, 16);
847             pContext->m_BlockOffset = 0;
848         }
849         FXSYS_memset8(pContext->m_Block + pContext->m_BlockOffset, (FX_BYTE)(16 - pContext->m_BlockOffset), 16 - pContext->m_BlockOffset);
850         CRYPT_AESEncrypt(pContext->m_Context, block_buf, pContext->m_Block, 16);
851         dest_buf.AppendBlock(block_buf, 16);
852     } else if (pContext->m_BlockOffset == 16) {
853         FX_BYTE block_buf[16];
854         CRYPT_AESDecrypt(pContext->m_Context, block_buf, pContext->m_Block, 16);
855         if (block_buf[15] <= 16) {
856             dest_buf.AppendBlock(block_buf, 16 - block_buf[15]);
857         }
858     }
859     FX_Free(pContext);
860     return TRUE;
861 }
862 FX_LPVOID CPDF_StandardCryptoHandler::DecryptStart(FX_DWORD objnum, FX_DWORD gennum)
863 {
864     return CryptStart(objnum, gennum, FALSE);
865 }
866 FX_DWORD CPDF_StandardCryptoHandler::DecryptGetSize(FX_DWORD src_size)
867 {
868     return m_Cipher == FXCIPHER_AES ? src_size - 16 : src_size;
869 }
870 FX_BOOL CPDF_StandardCryptoHandler::Init(CPDF_Dictionary* pEncryptDict, CPDF_SecurityHandler* pSecurityHandler)
871 {
872     FX_LPCBYTE key;
873     if (!pSecurityHandler->GetCryptInfo(m_Cipher, key, m_KeyLen)) {
874         return FALSE;
875     }
876     if (m_KeyLen > 32 || m_KeyLen < 0) {
877         return FALSE;
878     }
879     if (m_Cipher != FXCIPHER_NONE) {
880         FXSYS_memcpy32(m_EncryptKey, key, m_KeyLen);
881     }
882     if (m_Cipher == FXCIPHER_AES) {
883         m_pAESContext = FX_Alloc(FX_BYTE, 2048);
884     }
885     return TRUE;
886 }
887 FX_BOOL CPDF_StandardCryptoHandler::Init(int cipher, FX_LPCBYTE key, int keylen)
888 {
889     if (cipher == FXCIPHER_AES) {
890         switch(keylen) {
891             case 16:
892             case 24:
893             case 32:
894                 break;
895             default:
896                 return FALSE;
897         }
898     } else if (cipher == FXCIPHER_AES2) {
899         if (keylen != 32) {
900             return FALSE;
901         }
902     } else if (cipher == FXCIPHER_RC4) {
903         if (keylen < 5 || keylen > 16) {
904             return FALSE;
905         }
906     } else {
907         if (keylen > 32) {
908             keylen = 32;
909         }
910     }
911     m_Cipher = cipher;
912     m_KeyLen = keylen;
913     FXSYS_memcpy32(m_EncryptKey, key, keylen);
914     if (m_Cipher == FXCIPHER_AES) {
915         m_pAESContext = FX_Alloc(FX_BYTE, 2048);
916     }
917     return TRUE;
918 }
919 FX_BOOL CPDF_StandardCryptoHandler::DecryptStream(FX_LPVOID context, FX_LPCBYTE src_buf, FX_DWORD src_size,
920         CFX_BinaryBuf& dest_buf)
921 {
922     return CryptStream(context, src_buf, src_size, dest_buf, FALSE);
923 }
924 FX_BOOL CPDF_StandardCryptoHandler::DecryptFinish(FX_LPVOID context, CFX_BinaryBuf& dest_buf)
925 {
926     return CryptFinish(context, dest_buf, FALSE);
927 }
928 FX_DWORD CPDF_StandardCryptoHandler::EncryptGetSize(FX_DWORD objnum, FX_DWORD version, FX_LPCBYTE src_buf, FX_DWORD src_size)
929 {
930     if (m_Cipher == FXCIPHER_AES) {
931         return src_size + 32;
932     }
933     return src_size;
934 }
935 FX_BOOL CPDF_StandardCryptoHandler::EncryptContent(FX_DWORD objnum, FX_DWORD gennum, FX_LPCBYTE src_buf, FX_DWORD src_size,
936         FX_LPBYTE dest_buf, FX_DWORD& dest_size)
937 {
938     CryptBlock(TRUE, objnum, gennum, src_buf, src_size, dest_buf, dest_size);
939     return TRUE;
940 }
941 void CPDF_CryptoHandler::Decrypt(FX_DWORD objnum, FX_DWORD gennum, CFX_ByteString& str)
942 {
943     CFX_BinaryBuf dest_buf;
944     FX_LPVOID context = DecryptStart(objnum, gennum);
945     DecryptStream(context, (FX_LPCBYTE)str, str.GetLength(), dest_buf);
946     DecryptFinish(context, dest_buf);
947     str = dest_buf;
948 }
949 CPDF_StandardCryptoHandler::CPDF_StandardCryptoHandler()
950 {
951     m_pAESContext = NULL;
952     m_Cipher = FXCIPHER_NONE;
953     m_KeyLen = 0;
954 }
955 CPDF_StandardCryptoHandler::~CPDF_StandardCryptoHandler()
956 {
957     if (m_pAESContext) {
958         FX_Free(m_pAESContext);
959     }
960 }