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