Better tests for password protected documents.

core/fpdfapi/parser/cpdf_security_handler.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fpdfapi/parser/cpdf_security_handler.h"
 
 #include <time.h>
 
@@ skipping 210 matching lines @@
   uint64_t ret = 0;
   for (int i = 0; i < 4; ++i) {
     uint32_t value;
     FX_GET_32WORD(value, data, 4 * i);
     ret <<= 32;
     ret |= value;
     ret %= 3;
   }
   return (int)ret;
 }
+
 void Revision6_Hash(const uint8_t* password,
                     uint32_t size,
                     const uint8_t* salt,
                     const uint8_t* vector,
                     uint8_t* hash) {
-  int iBlockSize = 32;
-  uint8_t sha[128];
-  CRYPT_SHA256Start(sha);
-  CRYPT_SHA256Update(sha, password, size);
-  CRYPT_SHA256Update(sha, salt, 8);
-  if (vector) {
-    CRYPT_SHA256Update(sha, vector, 48);
-  }
+  CRYPT_sha256_context sha;
+  CRYPT_SHA256Start(&sha);
+  CRYPT_SHA256Update(&sha, password, size);
+  CRYPT_SHA256Update(&sha, salt, 8);
+  if (vector)
+    CRYPT_SHA256Update(&sha, vector, 48);
+
   uint8_t digest[32];
-  CRYPT_SHA256Finish(sha, digest);
+  CRYPT_SHA256Finish(&sha, digest);
+
   CFX_ByteTextBuf buf;
   uint8_t* input = digest;
   uint8_t* key = input;
   uint8_t* iv = input + 16;
   uint8_t* E = buf.GetBuffer();
   int iBufLen = buf.GetLength();
   CFX_ByteTextBuf interDigest;
   int i = 0;
+  int iBlockSize = 32;
   uint8_t* aes = FX_Alloc(uint8_t, 2048);
   while (i < 64 || i < E[iBufLen - 1] + 32) {
     int iRoundSize = size + iBlockSize;
     if (vector) {
       iRoundSize += 48;
     }
     iBufLen = iRoundSize * 64;
     buf.EstimateSize(iBufLen);
     E = buf.GetBuffer();
     CFX_ByteTextBuf content;
@@ skipping 33 matching lines @@
     }
     key = input;
     iv = input + 16;
     ++i;
   }
   FX_Free(aes);
   if (hash) {
     FXSYS_memcpy(hash, input, 32);
   }
 }
+
 bool CPDF_SecurityHandler::AES256_CheckPassword(const uint8_t* password,
                                                 uint32_t size,
                                                 bool bOwner,
                                                 uint8_t* key) {
-  CFX_ByteString okey =
-      m_pEncryptDict ? m_pEncryptDict->GetStringFor("O") : CFX_ByteString();
-  if (okey.GetLength() < 48) {
+  if (!m_pEncryptDict)
     return false;
-  }
-  CFX_ByteString ukey =
-      m_pEncryptDict ? m_pEncryptDict->GetStringFor("U") : CFX_ByteString();
-  if (ukey.GetLength() < 48) {
+
+  CFX_ByteString okey = m_pEncryptDict->GetStringFor("O");
+  if (okey.GetLength() < 48)
     return false;
-  }
-  const uint8_t* pkey = (bOwner ? okey : ukey).raw_str();
-  uint8_t sha[128];
+
+  CFX_ByteString ukey = m_pEncryptDict->GetStringFor("U");
+  if (ukey.GetLength() < 48)
+    return false;
+
+  const uint8_t* pkey = bOwner ? okey.raw_str() : ukey.raw_str();
+  CRYPT_sha256_context sha;
   uint8_t digest[32];
   if (m_Revision >= 6) {
     Revision6_Hash(password, size, (const uint8_t*)pkey + 32,
                    bOwner ? ukey.raw_str() : nullptr, digest);
   } else {
-    CRYPT_SHA256Start(sha);
-    CRYPT_SHA256Update(sha, password, size);
-    CRYPT_SHA256Update(sha, pkey + 32, 8);
-    if (bOwner) {
-      CRYPT_SHA256Update(sha, ukey.raw_str(), 48);
-    }
-    CRYPT_SHA256Finish(sha, digest);
+    CRYPT_SHA256Start(&sha);
+    CRYPT_SHA256Update(&sha, password, size);
+    CRYPT_SHA256Update(&sha, pkey + 32, 8);
+    if (bOwner)
+      CRYPT_SHA256Update(&sha, ukey.raw_str(), 48);
+
+    CRYPT_SHA256Finish(&sha, digest);
   }
-  if (FXSYS_memcmp(digest, pkey, 32) != 0) {
+  if (FXSYS_memcmp(digest, pkey, 32) != 0)
     return false;
-  }
-  if (!key) {
+
+  if (!key)
     return true;
-  }
+
   if (m_Revision >= 6) {
     Revision6_Hash(password, size, (const uint8_t*)pkey + 40,
                    bOwner ? ukey.raw_str() : nullptr, digest);
   } else {
-    CRYPT_SHA256Start(sha);
-    CRYPT_SHA256Update(sha, password, size);
-    CRYPT_SHA256Update(sha, pkey + 40, 8);
-    if (bOwner) {
-      CRYPT_SHA256Update(sha, ukey.raw_str(), 48);
-    }
-    CRYPT_SHA256Finish(sha, digest);
+    CRYPT_SHA256Start(&sha);
+    CRYPT_SHA256Update(&sha, password, size);
+    CRYPT_SHA256Update(&sha, pkey + 40, 8);
+    if (bOwner)
+      CRYPT_SHA256Update(&sha, ukey.raw_str(), 48);
+
+    CRYPT_SHA256Finish(&sha, digest);
   }
   CFX_ByteString ekey = m_pEncryptDict
                             ? m_pEncryptDict->GetStringFor(bOwner ? "OE" : "UE")
                             : CFX_ByteString();
   if (ekey.GetLength() < 32)
     return false;
 
   std::vector<uint8_t> aes(2048);
   CRYPT_AESSetKey(aes.data(), 16, digest, 32, false);
   uint8_t iv[16];
@@ skipping 163 matching lines @@
   int cipher = 0, key_len = 0;
   if (!LoadDict(pEncryptDict, type, cipher, key_len)) {
     return;
   }
   if (bDefault && (!owner_pass || owner_size == 0)) {
     owner_pass = user_pass;
     owner_size = user_size;
   }
   if (m_Revision >= 5) {
     int t = (int)time(nullptr);
-    uint8_t sha[128];
-    CRYPT_SHA256Start(sha);
-    CRYPT_SHA256Update(sha, (uint8_t*)&t, sizeof t);
-    CRYPT_SHA256Update(sha, m_EncryptKey, 32);
-    CRYPT_SHA256Update(sha, (uint8_t*)"there", 5);
-    CRYPT_SHA256Finish(sha, m_EncryptKey);
+    CRYPT_sha256_context sha;
+    CRYPT_SHA256Start(&sha);
+    CRYPT_SHA256Update(&sha, (uint8_t*)&t, sizeof t);
+    CRYPT_SHA256Update(&sha, m_EncryptKey, 32);
+    CRYPT_SHA256Update(&sha, (uint8_t*)"there", 5);
+    CRYPT_SHA256Finish(&sha, m_EncryptKey);
     AES256_SetPassword(pEncryptDict, user_pass, user_size, false, m_EncryptKey);
     if (bDefault) {
       AES256_SetPassword(pEncryptDict, owner_pass, owner_size, true,
                          m_EncryptKey);
       AES256_SetPerms(pEncryptDict, m_Permissions,
                       pEncryptDict->GetBooleanFor("EncryptMetadata", true),
                       m_EncryptKey);
     }
     return;
   }
@@ skipping 73 matching lines @@
                                     uint32_t user_size,
                                     uint32_t type) {
   OnCreate(pEncryptDict, pIdArray, user_pass, user_size, nullptr, 0, false,
            type);
 }
 void CPDF_SecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict,
                                               const uint8_t* password,
                                               uint32_t size,
                                               bool bOwner,
                                               const uint8_t* key) {
-  uint8_t sha[128];
-  CRYPT_SHA1Start(sha);
-  CRYPT_SHA1Update(sha, key, 32);
-  CRYPT_SHA1Update(sha, (uint8_t*)"hello", 5);
+  CRYPT_sha1_context sha;
+  CRYPT_SHA1Start(&sha);
+  CRYPT_SHA1Update(&sha, key, 32);
+  CRYPT_SHA1Update(&sha, (uint8_t*)"hello", 5);
+
   uint8_t digest[20];
-  CRYPT_SHA1Finish(sha, digest);
+  CRYPT_SHA1Finish(&sha, digest);
+
   CFX_ByteString ukey = pEncryptDict->GetStringFor("U");
+  CRYPT_sha256_context sha2;
   uint8_t digest1[48];
   if (m_Revision >= 6) {
     Revision6_Hash(password, size, digest, bOwner ? ukey.raw_str() : nullptr,
                    digest1);
   } else {
-    CRYPT_SHA256Start(sha);
-    CRYPT_SHA256Update(sha, password, size);
-    CRYPT_SHA256Update(sha, digest, 8);
+    CRYPT_SHA256Start(&sha2);
+    CRYPT_SHA256Update(&sha2, password, size);
+    CRYPT_SHA256Update(&sha2, digest, 8);
     if (bOwner) {
-      CRYPT_SHA256Update(sha, ukey.raw_str(), ukey.GetLength());
+      CRYPT_SHA256Update(&sha2, ukey.raw_str(), ukey.GetLength());
     }
-    CRYPT_SHA256Finish(sha, digest1);
+    CRYPT_SHA256Finish(&sha2, digest1);
   }
   FXSYS_memcpy(digest1 + 32, digest, 16);
   pEncryptDict->SetNewFor<CPDF_String>(bOwner ? "O" : "U",
                                        CFX_ByteString(digest1, 48), false);
   if (m_Revision >= 6) {
     Revision6_Hash(password, size, digest + 8,
                    bOwner ? ukey.raw_str() : nullptr, digest1);
   } else {
-    CRYPT_SHA256Start(sha);
-    CRYPT_SHA256Update(sha, password, size);
-    CRYPT_SHA256Update(sha, digest + 8, 8);
+    CRYPT_SHA256Start(&sha2);
+    CRYPT_SHA256Update(&sha2, password, size);
+    CRYPT_SHA256Update(&sha2, digest + 8, 8);
     if (bOwner) {
-      CRYPT_SHA256Update(sha, ukey.raw_str(), ukey.GetLength());
+      CRYPT_SHA256Update(&sha2, ukey.raw_str(), ukey.GetLength());
     }
-    CRYPT_SHA256Finish(sha, digest1);
+    CRYPT_SHA256Finish(&sha2, digest1);
   }
   uint8_t* aes = FX_Alloc(uint8_t, 2048);
   CRYPT_AESSetKey(aes, 16, digest1, 32, true);
   uint8_t iv[16];
   FXSYS_memset(iv, 0, 16);
   CRYPT_AESSetIV(aes, iv);
   CRYPT_AESEncrypt(aes, digest1, key, 32);
   FX_Free(aes);
   pEncryptDict->SetNewFor<CPDF_String>(bOwner ? "OE" : "UE",
                                        CFX_ByteString(digest1, 32), false);
@@ skipping 19 matching lines @@
   uint8_t* aes = FX_Alloc(uint8_t, 2048);
   CRYPT_AESSetKey(aes, 16, key, 32, true);
   uint8_t iv[16], buf1[16];
   FXSYS_memset(iv, 0, 16);
   CRYPT_AESSetIV(aes, iv);
   CRYPT_AESEncrypt(aes, buf1, buf, 16);
   FX_Free(aes);
   pEncryptDict->SetNewFor<CPDF_String>("Perms", CFX_ByteString(buf1, 16),
                                        false);
 }