Split off IPDF_SecurityHandler and CPDF_StandardSecurityHandler.

R=dsinclair@chromium.org

Review URL: https://codereview.chromium.org/1781593003 .

9 files changed, 860 insertions, 812 deletions

diff --git a/BUILD.gn b/BUILD.gn
index e238d31714..5d93a0c995 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -248,6 +248,7 @@ static_library("fpdfapi") {
     "core/include/fpdfapi/fpdf_render.h",
     "core/include/fpdfapi/fpdf_resource.h",
     "core/include/fpdfapi/fpdf_serial.h",
+    "core/include/fpdfapi/ipdf_security_handler.h",
     "core/src/fpdfapi/fpdf_basic_module.cpp",
     "core/src/fpdfapi/fpdf_cmaps/CNS1/Adobe-CNS1-UCS2_5.cpp",
     "core/src/fpdfapi/fpdf_cmaps/CNS1/B5pc-H_0.cpp",
@@ -337,6 +338,8 @@ static_library("fpdfapi") {
     "core/src/fpdfapi/fpdf_parser/cpdf_document.cpp",
     "core/src/fpdfapi/fpdf_parser/cpdf_parser.cpp",
     "core/src/fpdfapi/fpdf_parser/cpdf_simple_parser.cpp",
+    "core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.cpp",
+    "core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.h",
     "core/src/fpdfapi/fpdf_parser/cpdf_syntax_parser.cpp",
     "core/src/fpdfapi/fpdf_parser/cpdf_syntax_parser.h",
     "core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp",
diff --git a/core/include/fpdfapi/fpdf_parser.h b/core/include/fpdfapi/fpdf_parser.h
index 06030701b4..2134d0159b 100644
--- a/core/include/fpdfapi/fpdf_parser.h
+++ b/core/include/fpdfapi/fpdf_parser.h
@@ -64,125 +64,6 @@ class ScopedSetInsertion {
 // Indexed by 8-bit char code, contains unicode code points.
 extern const FX_WORD PDFDocEncoding[256];
 
-#define FXCIPHER_NONE 0
-#define FXCIPHER_RC4 1
-#define FXCIPHER_AES 2
-#define FXCIPHER_AES2 3
-
-class IPDF_SecurityHandler {
- public:
-  virtual ~IPDF_SecurityHandler() {}
-
-  virtual FX_BOOL OnInit(CPDF_Parser* pParser,
-                         CPDF_Dictionary* pEncryptDict) = 0;
-
-  virtual FX_DWORD GetPermissions() = 0;
-  virtual FX_BOOL GetCryptInfo(int& cipher,
-                               const uint8_t*& buffer,
-                               int& keylen) = 0;
-
-  virtual FX_BOOL IsMetadataEncrypted() = 0;
-  virtual CPDF_CryptoHandler* CreateCryptoHandler() = 0;
-};
-
-#define PDF_ENCRYPT_CONTENT 0
-
-class CPDF_StandardSecurityHandler : public IPDF_SecurityHandler {
- public:
-  CPDF_StandardSecurityHandler();
-  ~CPDF_StandardSecurityHandler() override;
-
-  // IPDF_SecurityHandler:
-  FX_BOOL OnInit(CPDF_Parser* pParser, CPDF_Dictionary* pEncryptDict) override;
-  FX_DWORD GetPermissions() override;
-  FX_BOOL GetCryptInfo(int& cipher,
-                       const uint8_t*& buffer,
-                       int& keylen) override;
-  FX_BOOL IsMetadataEncrypted() override;
-  CPDF_CryptoHandler* CreateCryptoHandler() override;
-
-  void OnCreate(CPDF_Dictionary* pEncryptDict,
-                CPDF_Array* pIdArray,
-                const uint8_t* user_pass,
-                FX_DWORD user_size,
-                const uint8_t* owner_pass,
-                FX_DWORD owner_size,
-                FX_DWORD type = PDF_ENCRYPT_CONTENT);
-
-  void OnCreate(CPDF_Dictionary* pEncryptDict,
-                CPDF_Array* pIdArray,
-                const uint8_t* user_pass,
-                FX_DWORD user_size,
-                FX_DWORD type = PDF_ENCRYPT_CONTENT);
-
-  CFX_ByteString GetUserPassword(const uint8_t* owner_pass,
-                                 FX_DWORD pass_size,
-                                 int32_t key_len);
-  int CheckPassword(const uint8_t* password,
-                    FX_DWORD pass_size,
-                    FX_BOOL bOwner,
-                    uint8_t* key,
-                    int key_len);
-
- private:
-  int m_Version;
-
-  int m_Revision;
-
-  CPDF_Parser* m_pParser;
-
-  CPDF_Dictionary* m_pEncryptDict;
-
-  FX_BOOL LoadDict(CPDF_Dictionary* pEncryptDict);
-  FX_BOOL LoadDict(CPDF_Dictionary* pEncryptDict,
-                   FX_DWORD type,
-                   int& cipher,
-                   int& key_len);
-
-  FX_BOOL CheckUserPassword(const uint8_t* password,
-                            FX_DWORD pass_size,
-                            FX_BOOL bIgnoreEncryptMeta,
-                            uint8_t* key,
-                            int32_t key_len);
-
-  FX_BOOL CheckOwnerPassword(const uint8_t* password,
-                             FX_DWORD pass_size,
-                             uint8_t* key,
-                             int32_t key_len);
-  FX_BOOL AES256_CheckPassword(const uint8_t* password,
-                               FX_DWORD size,
-                               FX_BOOL bOwner,
-                               uint8_t* key);
-  void AES256_SetPassword(CPDF_Dictionary* pEncryptDict,
-                          const uint8_t* password,
-                          FX_DWORD size,
-                          FX_BOOL bOwner,
-                          const uint8_t* key);
-  void AES256_SetPerms(CPDF_Dictionary* pEncryptDict,
-                       FX_DWORD permission,
-                       FX_BOOL bEncryptMetadata,
-                       const uint8_t* key);
-  void OnCreate(CPDF_Dictionary* pEncryptDict,
-                CPDF_Array* pIdArray,
-                const uint8_t* user_pass,
-                FX_DWORD user_size,
-                const uint8_t* owner_pass,
-                FX_DWORD owner_size,
-                FX_BOOL bDefault,
-                FX_DWORD type);
-  FX_BOOL CheckSecurity(int32_t key_len);
-
-  FX_DWORD m_Permissions;
-
-  int m_Cipher;
-
-  uint8_t m_EncryptKey[32];
-
-  int m_KeyLen;
-};
-
-IPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler();
-
 class CPDF_CryptoHandler {
  public:
   virtual ~CPDF_CryptoHandler() {}
@@ -215,6 +96,7 @@ class CPDF_CryptoHandler {
 
   void Decrypt(FX_DWORD objnum, FX_DWORD version, CFX_ByteString& str);
 };
+
 class CPDF_StandardCryptoHandler : public CPDF_CryptoHandler {
  public:
   CPDF_StandardCryptoHandler();
diff --git a/core/include/fpdfapi/ipdf_security_handler.h b/core/include/fpdfapi/ipdf_security_handler.h
new file mode 100644
index 0000000000..699cf38c3a
--- /dev/null
+++ b/core/include/fpdfapi/ipdf_security_handler.h
@@ -0,0 +1,36 @@
+// Copyright 2016 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
+
+#ifndef CORE_INCLUDE_FPDFAPI_IPDF_SECURITY_HANDLER_H_
+#define CORE_INCLUDE_FPDFAPI_IPDF_SECURITY_HANDLER_H_
+
+#include "core/include/fxcrt/fx_system.h"
+
+class CPDF_Parser;
+class CPDF_Dictionary;
+class CPDF_CryptoHandler;
+
+#define FXCIPHER_NONE 0
+#define FXCIPHER_RC4 1
+#define FXCIPHER_AES 2
+#define FXCIPHER_AES2 3
+
+class IPDF_SecurityHandler {
+ public:
+  virtual ~IPDF_SecurityHandler();
+  virtual FX_BOOL OnInit(CPDF_Parser* pParser,
+                         CPDF_Dictionary* pEncryptDict) = 0;
+
+  virtual FX_DWORD GetPermissions() = 0;
+  virtual FX_BOOL GetCryptInfo(int& cipher,
+                               const uint8_t*& buffer,
+                               int& keylen) = 0;
+
+  virtual FX_BOOL IsMetadataEncrypted() = 0;
+  virtual CPDF_CryptoHandler* CreateCryptoHandler() = 0;
+};
+
+#endif  // CORE_INCLUDE_FPDFAPI_IPDF_SECURITY_HANDLER_H_
diff --git a/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp b/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp
index 88bd272e1e..4cfafc51b6 100644
--- a/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp
+++ b/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp
@@ -13,6 +13,7 @@
 #include "core/include/fpdfapi/fpdf_parser.h"
 #include "core/include/fpdfapi/fpdf_serial.h"
 #include "core/include/fxcrt/fx_ext.h"
+#include "core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.h"
 #include "third_party/base/stl_util.h"
 
 #define PDF_OBJECTSTREAM_MAXLENGTH (256 * 1024)
diff --git a/core/src/fpdfapi/fpdf_parser/cpdf_parser.cpp b/core/src/fpdfapi/fpdf_parser/cpdf_parser.cpp
index b7d1012b85..675eec8f3a 100644
--- a/core/src/fpdfapi/fpdf_parser/cpdf_parser.cpp
+++ b/core/src/fpdfapi/fpdf_parser/cpdf_parser.cpp
@@ -12,6 +12,7 @@
 #include "core/include/fpdfapi/fpdf_parser.h"
 #include "core/include/fxcrt/fx_ext.h"
 #include "core/include/fxcrt/fx_safe_types.h"
+#include "core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.h"
 #include "core/src/fpdfapi/fpdf_parser/cpdf_syntax_parser.h"
 #include "core/src/fpdfapi/fpdf_parser/fpdf_parser_utility.h"
 #include "third_party/base/stl_util.h"
diff --git a/core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.cpp b/core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.cpp
new file mode 100644
index 0000000000..84da42ec19
--- /dev/null
+++ b/core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.cpp
@@ -0,0 +1,709 @@
+// 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/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.h"
+
+#include "core/include/fdrm/fx_crypt.h"
+#include "core/include/fpdfapi/cpdf_parser.h"
+#include "core/include/fpdfapi/fpdf_parser.h"
+
+namespace {
+
+const uint8_t defpasscode[32] = {
+    0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41, 0x64, 0x00, 0x4e,
+    0x56, 0xff, 0xfa, 0x01, 0x08, 0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68,
+    0x3e, 0x80, 0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a};
+
+void CalcEncryptKey(CPDF_Dictionary* pEncrypt,
+                    const uint8_t* password,
+                    FX_DWORD pass_size,
+                    uint8_t* key,
+                    int keylen,
+                    FX_BOOL bIgnoreMeta,
+                    CPDF_Array* pIdArray) {
+  int revision = pEncrypt->GetIntegerBy("R");
+  uint8_t passcode[32];
+  for (FX_DWORD i = 0; i < 32; i++) {
+    passcode[i] = i < pass_size ? password[i] : defpasscode[i - pass_size];
+  }
+  uint8_t md5[100];
+  CRYPT_MD5Start(md5);
+  CRYPT_MD5Update(md5, passcode, 32);
+  CFX_ByteString okey = pEncrypt->GetStringBy("O");
+  CRYPT_MD5Update(md5, (uint8_t*)okey.c_str(), okey.GetLength());
+  FX_DWORD perm = pEncrypt->GetIntegerBy("P");
+  CRYPT_MD5Update(md5, (uint8_t*)&perm, 4);
+  if (pIdArray) {
+    CFX_ByteString id = pIdArray->GetStringAt(0);
+    CRYPT_MD5Update(md5, (uint8_t*)id.c_str(), id.GetLength());
+  }
+  if (!bIgnoreMeta && revision >= 3 &&
+      !pEncrypt->GetIntegerBy("EncryptMetadata", 1)) {
+    FX_DWORD tag = (FX_DWORD)-1;
+    CRYPT_MD5Update(md5, (uint8_t*)&tag, 4);
+  }
+  uint8_t digest[16];
+  CRYPT_MD5Finish(md5, digest);
+  FX_DWORD copy_len = keylen;
+  if (copy_len > sizeof(digest)) {
+    copy_len = sizeof(digest);
+  }
+  if (revision >= 3) {
+    for (int i = 0; i < 50; i++) {
+      CRYPT_MD5Generate(digest, copy_len, digest);
+    }
+  }
+  FXSYS_memset(key, 0, keylen);
+  FXSYS_memcpy(key, digest, copy_len);
+}
+
+}  // namespace
+
+IPDF_SecurityHandler::~IPDF_SecurityHandler() {}
+
+CPDF_StandardSecurityHandler::CPDF_StandardSecurityHandler() {
+  m_Version = 0;
+  m_Revision = 0;
+  m_pParser = NULL;
+  m_pEncryptDict = NULL;
+  m_Permissions = 0;
+  m_Cipher = FXCIPHER_NONE;
+  m_KeyLen = 0;
+}
+
+CPDF_StandardSecurityHandler::~CPDF_StandardSecurityHandler() {}
+
+CPDF_CryptoHandler* CPDF_StandardSecurityHandler::CreateCryptoHandler() {
+  return new CPDF_StandardCryptoHandler;
+}
+
+FX_BOOL CPDF_StandardSecurityHandler::OnInit(CPDF_Parser* pParser,
+                                             CPDF_Dictionary* pEncryptDict) {
+  m_pParser = pParser;
+  if (!LoadDict(pEncryptDict)) {
+    return FALSE;
+  }
+  if (m_Cipher == FXCIPHER_NONE) {
+    return TRUE;
+  }
+  return CheckSecurity(m_KeyLen);
+}
+FX_BOOL CPDF_StandardSecurityHandler::CheckSecurity(int32_t key_len) {
+  CFX_ByteString password = m_pParser->GetPassword();
+  if (CheckPassword(password, password.GetLength(), TRUE, m_EncryptKey,
+                    key_len)) {
+    if (password.IsEmpty()) {
+      if (!CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey,
+                         key_len)) {
+        return FALSE;
+      }
+    }
+    return TRUE;
+  }
+  return CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey,
+                       key_len);
+}
+FX_DWORD CPDF_StandardSecurityHandler::GetPermissions() {
+  return m_Permissions;
+}
+static FX_BOOL _LoadCryptInfo(CPDF_Dictionary* pEncryptDict,
+                              const CFX_ByteStringC& name,
+                              int& cipher,
+                              int& keylen) {
+  int Version = pEncryptDict->GetIntegerBy("V");
+  cipher = FXCIPHER_RC4;
+  keylen = 0;
+  if (Version >= 4) {
+    CPDF_Dictionary* pCryptFilters = pEncryptDict->GetDictBy("CF");
+    if (!pCryptFilters) {
+      return FALSE;
+    }
+    if (name == "Identity") {
+      cipher = FXCIPHER_NONE;
+    } else {
+      CPDF_Dictionary* pDefFilter = pCryptFilters->GetDictBy(name);
+      if (!pDefFilter) {
+        return FALSE;
+      }
+      int nKeyBits = 0;
+      if (Version == 4) {
+        nKeyBits = pDefFilter->GetIntegerBy("Length", 0);
+        if (nKeyBits == 0) {
+          nKeyBits = pEncryptDict->GetIntegerBy("Length", 128);
+        }
+      } else {
+        nKeyBits = pEncryptDict->GetIntegerBy("Length", 256);
+      }
+      if (nKeyBits < 40) {
+        nKeyBits *= 8;
+      }
+      keylen = nKeyBits / 8;
+      CFX_ByteString cipher_name = pDefFilter->GetStringBy("CFM");
+      if (cipher_name == "AESV2" || cipher_name == "AESV3") {
+        cipher = FXCIPHER_AES;
+      }
+    }
+  } else {
+    keylen = Version > 1 ? pEncryptDict->GetIntegerBy("Length", 40) / 8 : 5;
+  }
+  if (keylen > 32 || keylen < 0) {
+    return FALSE;
+  }
+  return TRUE;
+}
+
+FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict) {
+  m_pEncryptDict = pEncryptDict;
+  m_Version = pEncryptDict->GetIntegerBy("V");
+  m_Revision = pEncryptDict->GetIntegerBy("R");
+  m_Permissions = pEncryptDict->GetIntegerBy("P", -1);
+  if (m_Version < 4) {
+    return _LoadCryptInfo(pEncryptDict, CFX_ByteString(), m_Cipher, m_KeyLen);
+  }
+  CFX_ByteString stmf_name = pEncryptDict->GetStringBy("StmF");
+  CFX_ByteString strf_name = pEncryptDict->GetStringBy("StrF");
+  if (stmf_name != strf_name) {
+    return FALSE;
+  }
+  if (!_LoadCryptInfo(pEncryptDict, strf_name, m_Cipher, m_KeyLen)) {
+    return FALSE;
+  }
+  return TRUE;
+}
+
+FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict,
+                                               FX_DWORD type,
+                                               int& cipher,
+                                               int& key_len) {
+  m_pEncryptDict = pEncryptDict;
+  m_Version = pEncryptDict->GetIntegerBy("V");
+  m_Revision = pEncryptDict->GetIntegerBy("R");
+  m_Permissions = pEncryptDict->GetIntegerBy("P", -1);
+  CFX_ByteString strf_name, stmf_name;
+  if (m_Version >= 4) {
+    stmf_name = pEncryptDict->GetStringBy("StmF");
+    strf_name = pEncryptDict->GetStringBy("StrF");
+    if (stmf_name != strf_name) {
+      return FALSE;
+    }
+  }
+  if (!_LoadCryptInfo(pEncryptDict, strf_name, cipher, key_len)) {
+    return FALSE;
+  }
+  m_Cipher = cipher;
+  m_KeyLen = key_len;
+  return TRUE;
+}
+
+FX_BOOL CPDF_StandardSecurityHandler::GetCryptInfo(int& cipher,
+                                                   const uint8_t*& buffer,
+                                                   int& keylen) {
+  cipher = m_Cipher;
+  buffer = m_EncryptKey;
+  keylen = m_KeyLen;
+  return TRUE;
+}
+#define FX_GET_32WORD(n, b, i)                                        \
+  {                                                                   \
+    (n) = (FX_DWORD)(                                                 \
+        ((uint64_t)(b)[(i)] << 24) | ((uint64_t)(b)[(i) + 1] << 16) | \
+        ((uint64_t)(b)[(i) + 2] << 8) | ((uint64_t)(b)[(i) + 3]));    \
+  }
+int BigOrder64BitsMod3(uint8_t* data) {
+  uint64_t ret = 0;
+  for (int i = 0; i < 4; ++i) {
+    FX_DWORD value;
+    FX_GET_32WORD(value, data, 4 * i);
+    ret <<= 32;
+    ret |= value;
+    ret %= 3;
+  }
+  return (int)ret;
+}
+void Revision6_Hash(const uint8_t* password,
+                    FX_DWORD 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);
+  }
+  uint8_t digest[32];
+  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;
+  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;
+    for (int j = 0; j < 64; ++j) {
+      content.AppendBlock(password, size);
+      content.AppendBlock(input, iBlockSize);
+      if (vector) {
+        content.AppendBlock(vector, 48);
+      }
+    }
+    CRYPT_AESSetKey(aes, 16, key, 16, TRUE);
+    CRYPT_AESSetIV(aes, iv);
+    CRYPT_AESEncrypt(aes, E, content.GetBuffer(), iBufLen);
+    int iHash = 0;
+    switch (BigOrder64BitsMod3(E)) {
+      case 0:
+        iHash = 0;
+        iBlockSize = 32;
+        break;
+      case 1:
+        iHash = 1;
+        iBlockSize = 48;
+        break;
+      default:
+        iHash = 2;
+        iBlockSize = 64;
+        break;
+    }
+    interDigest.EstimateSize(iBlockSize);
+    input = interDigest.GetBuffer();
+    if (iHash == 0) {
+      CRYPT_SHA256Generate(E, iBufLen, input);
+    } else if (iHash == 1) {
+      CRYPT_SHA384Generate(E, iBufLen, input);
+    } else if (iHash == 2) {
+      CRYPT_SHA512Generate(E, iBufLen, input);
+    }
+    key = input;
+    iv = input + 16;
+    ++i;
+  }
+  FX_Free(aes);
+  if (hash) {
+    FXSYS_memcpy(hash, input, 32);
+  }
+}
+FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(
+    const uint8_t* password,
+    FX_DWORD size,
+    FX_BOOL bOwner,
+    uint8_t* key) {
+  CFX_ByteString okey =
+      m_pEncryptDict ? m_pEncryptDict->GetStringBy("O") : CFX_ByteString();
+  if (okey.GetLength() < 48) {
+    return FALSE;
+  }
+  CFX_ByteString ukey =
+      m_pEncryptDict ? m_pEncryptDict->GetStringBy("U") : CFX_ByteString();
+  if (ukey.GetLength() < 48) {
+    return FALSE;
+  }
+  const uint8_t* pkey = bOwner ? (const uint8_t*)okey : (const uint8_t*)ukey;
+  uint8_t sha[128];
+  uint8_t digest[32];
+  if (m_Revision >= 6) {
+    Revision6_Hash(password, size, (const uint8_t*)pkey + 32,
+                   (bOwner ? (const uint8_t*)ukey : NULL), digest);
+  } else {
+    CRYPT_SHA256Start(sha);
+    CRYPT_SHA256Update(sha, password, size);
+    CRYPT_SHA256Update(sha, pkey + 32, 8);
+    if (bOwner) {
+      CRYPT_SHA256Update(sha, ukey, 48);
+    }
+    CRYPT_SHA256Finish(sha, digest);
+  }
+  if (FXSYS_memcmp(digest, pkey, 32) != 0) {
+    return FALSE;
+  }
+  if (!key) {
+    return TRUE;
+  }
+  if (m_Revision >= 6) {
+    Revision6_Hash(password, size, (const uint8_t*)pkey + 40,
+                   (bOwner ? (const uint8_t*)ukey : NULL), digest);
+  } else {
+    CRYPT_SHA256Start(sha);
+    CRYPT_SHA256Update(sha, password, size);
+    CRYPT_SHA256Update(sha, pkey + 40, 8);
+    if (bOwner) {
+      CRYPT_SHA256Update(sha, ukey, 48);
+    }
+    CRYPT_SHA256Finish(sha, digest);
+  }
+  CFX_ByteString ekey = m_pEncryptDict
+                            ? m_pEncryptDict->GetStringBy(bOwner ? "OE" : "UE")
+                            : CFX_ByteString();
+  if (ekey.GetLength() < 32) {
+    return FALSE;
+  }
+  uint8_t* aes = FX_Alloc(uint8_t, 2048);
+  CRYPT_AESSetKey(aes, 16, digest, 32, FALSE);
+  uint8_t iv[16];
+  FXSYS_memset(iv, 0, 16);
+  CRYPT_AESSetIV(aes, iv);
+  CRYPT_AESDecrypt(aes, key, ekey, 32);
+  CRYPT_AESSetKey(aes, 16, key, 32, FALSE);
+  CRYPT_AESSetIV(aes, iv);
+  CFX_ByteString perms = m_pEncryptDict->GetStringBy("Perms");
+  if (perms.IsEmpty()) {
+    return FALSE;
+  }
+  uint8_t perms_buf[16];
+  FXSYS_memset(perms_buf, 0, sizeof(perms_buf));
+  FX_DWORD copy_len = sizeof(perms_buf);
+  if (copy_len > (FX_DWORD)perms.GetLength()) {
+    copy_len = perms.GetLength();
+  }
+  FXSYS_memcpy(perms_buf, (const uint8_t*)perms, copy_len);
+  uint8_t buf[16];
+  CRYPT_AESDecrypt(aes, buf, perms_buf, 16);
+  FX_Free(aes);
+  if (buf[9] != 'a' || buf[10] != 'd' || buf[11] != 'b') {
+    return FALSE;
+  }
+  if (FXDWORD_GET_LSBFIRST(buf) != m_Permissions) {
+    return FALSE;
+  }
+  if ((buf[8] == 'T' && !IsMetadataEncrypted()) ||
+      (buf[8] == 'F' && IsMetadataEncrypted())) {
+    return FALSE;
+  }
+  return TRUE;
+}
+
+int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password,
+                                                FX_DWORD size,
+                                                FX_BOOL bOwner,
+                                                uint8_t* key,
+                                                int32_t key_len) {
+  if (m_Revision >= 5) {
+    return AES256_CheckPassword(password, size, bOwner, key);
+  }
+  uint8_t keybuf[32];
+  if (!key) {
+    key = keybuf;
+  }
+  if (bOwner) {
+    return CheckOwnerPassword(password, size, key, key_len);
+  }
+  return CheckUserPassword(password, size, FALSE, key, key_len) ||
+         CheckUserPassword(password, size, TRUE, key, key_len);
+}
+FX_BOOL CPDF_StandardSecurityHandler::CheckUserPassword(
+    const uint8_t* password,
+    FX_DWORD pass_size,
+    FX_BOOL bIgnoreEncryptMeta,
+    uint8_t* key,
+    int32_t key_len) {
+  CalcEncryptKey(m_pEncryptDict, password, pass_size, key, key_len,
+                 bIgnoreEncryptMeta, m_pParser->GetIDArray());
+  CFX_ByteString ukey =
+      m_pEncryptDict ? m_pEncryptDict->GetStringBy("U") : CFX_ByteString();
+  if (ukey.GetLength() < 16) {
+    return FALSE;
+  }
+  uint8_t ukeybuf[32];
+  if (m_Revision == 2) {
+    FXSYS_memcpy(ukeybuf, defpasscode, 32);
+    CRYPT_ArcFourCryptBlock(ukeybuf, 32, key, key_len);
+  } else {
+    uint8_t test[32], tmpkey[32];
+    FX_DWORD copy_len = sizeof(test);
+    if (copy_len > (FX_DWORD)ukey.GetLength()) {
+      copy_len = ukey.GetLength();
+    }
+    FXSYS_memset(test, 0, sizeof(test));
+    FXSYS_memset(tmpkey, 0, sizeof(tmpkey));
+    FXSYS_memcpy(test, ukey.c_str(), copy_len);
+    for (int i = 19; i >= 0; i--) {
+      for (int j = 0; j < key_len; j++) {
+        tmpkey[j] = key[j] ^ i;
+      }
+      CRYPT_ArcFourCryptBlock(test, 32, tmpkey, key_len);
+    }
+    uint8_t md5[100];
+    CRYPT_MD5Start(md5);
+    CRYPT_MD5Update(md5, defpasscode, 32);
+    CPDF_Array* pIdArray = m_pParser->GetIDArray();
+    if (pIdArray) {
+      CFX_ByteString id = pIdArray->GetStringAt(0);
+      CRYPT_MD5Update(md5, (uint8_t*)id.c_str(), id.GetLength());
+    }
+    CRYPT_MD5Finish(md5, ukeybuf);
+    return FXSYS_memcmp(test, ukeybuf, 16) == 0;
+  }
+  if (FXSYS_memcmp((void*)ukey.c_str(), ukeybuf, 16) == 0) {
+    return TRUE;
+  }
+  return FALSE;
+}
+CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(
+    const uint8_t* owner_pass,
+    FX_DWORD pass_size,
+    int32_t key_len) {
+  CFX_ByteString okey = m_pEncryptDict->GetStringBy("O");
+  uint8_t passcode[32];
+  FX_DWORD i;
+  for (i = 0; i < 32; i++) {
+    passcode[i] = i < pass_size ? owner_pass[i] : defpasscode[i - pass_size];
+  }
+  uint8_t digest[16];
+  CRYPT_MD5Generate(passcode, 32, digest);
+  if (m_Revision >= 3) {
+    for (int i = 0; i < 50; i++) {
+      CRYPT_MD5Generate(digest, 16, digest);
+    }
+  }
+  uint8_t enckey[32];
+  FXSYS_memset(enckey, 0, sizeof(enckey));
+  FX_DWORD copy_len = key_len;
+  if (copy_len > sizeof(digest)) {
+    copy_len = sizeof(digest);
+  }
+  FXSYS_memcpy(enckey, digest, copy_len);
+  int okeylen = okey.GetLength();
+  if (okeylen > 32) {
+    okeylen = 32;
+  }
+  uint8_t okeybuf[64];
+  FXSYS_memset(okeybuf, 0, sizeof(okeybuf));
+  FXSYS_memcpy(okeybuf, okey.c_str(), okeylen);
+  if (m_Revision == 2) {
+    CRYPT_ArcFourCryptBlock(okeybuf, okeylen, enckey, key_len);
+  } else {
+    for (int i = 19; i >= 0; i--) {
+      uint8_t tempkey[32];
+      FXSYS_memset(tempkey, 0, sizeof(tempkey));
+      for (int j = 0; j < m_KeyLen; j++) {
+        tempkey[j] = enckey[j] ^ i;
+      }
+      CRYPT_ArcFourCryptBlock(okeybuf, okeylen, tempkey, key_len);
+    }
+  }
+  int len = 32;
+  while (len && defpasscode[len - 1] == okeybuf[len - 1]) {
+    len--;
+  }
+  return CFX_ByteString(okeybuf, len);
+}
+FX_BOOL CPDF_StandardSecurityHandler::CheckOwnerPassword(
+    const uint8_t* password,
+    FX_DWORD pass_size,
+    uint8_t* key,
+    int32_t key_len) {
+  CFX_ByteString user_pass = GetUserPassword(password, pass_size, key_len);
+  if (CheckUserPassword(user_pass, user_pass.GetLength(), FALSE, key,
+                        key_len)) {
+    return TRUE;
+  }
+  return CheckUserPassword(user_pass, user_pass.GetLength(), TRUE, key,
+                           key_len);
+}
+FX_BOOL CPDF_StandardSecurityHandler::IsMetadataEncrypted() {
+  return m_pEncryptDict->GetBooleanBy("EncryptMetadata", TRUE);
+}
+
+void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict,
+                                            CPDF_Array* pIdArray,
+                                            const uint8_t* user_pass,
+                                            FX_DWORD user_size,
+                                            const uint8_t* owner_pass,
+                                            FX_DWORD owner_size,
+                                            FX_BOOL bDefault,
+                                            FX_DWORD type) {
+  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(NULL);
+    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);
+    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->GetBooleanBy("EncryptMetadata", TRUE),
+                      m_EncryptKey);
+    }
+    return;
+  }
+  if (bDefault) {
+    uint8_t passcode[32];
+    FX_DWORD i;
+    for (i = 0; i < 32; i++) {
+      passcode[i] =
+          i < owner_size ? owner_pass[i] : defpasscode[i - owner_size];
+    }
+    uint8_t digest[16];
+    CRYPT_MD5Generate(passcode, 32, digest);
+    if (m_Revision >= 3) {
+      for (int i = 0; i < 50; i++) {
+        CRYPT_MD5Generate(digest, 16, digest);
+      }
+    }
+    uint8_t enckey[32];
+    FXSYS_memcpy(enckey, digest, key_len);
+    for (i = 0; i < 32; i++) {
+      passcode[i] = i < user_size ? user_pass[i] : defpasscode[i - user_size];
+    }
+    CRYPT_ArcFourCryptBlock(passcode, 32, enckey, key_len);
+    uint8_t tempkey[32];
+    if (m_Revision >= 3) {
+      for (i = 1; i <= 19; i++) {
+        for (int j = 0; j < key_len; j++) {
+          tempkey[j] = enckey[j] ^ (uint8_t)i;
+        }
+        CRYPT_ArcFourCryptBlock(passcode, 32, tempkey, key_len);
+      }
+    }
+    pEncryptDict->SetAtString("O", CFX_ByteString(passcode, 32));
+  }
+  CalcEncryptKey(m_pEncryptDict, (uint8_t*)user_pass, user_size, m_EncryptKey,
+                 key_len, FALSE, pIdArray);
+  if (m_Revision < 3) {
+    uint8_t tempbuf[32];
+    FXSYS_memcpy(tempbuf, defpasscode, 32);
+    CRYPT_ArcFourCryptBlock(tempbuf, 32, m_EncryptKey, key_len);
+    pEncryptDict->SetAtString("U", CFX_ByteString(tempbuf, 32));
+  } else {
+    uint8_t md5[100];
+    CRYPT_MD5Start(md5);
+    CRYPT_MD5Update(md5, defpasscode, 32);
+    if (pIdArray) {
+      CFX_ByteString id = pIdArray->GetStringAt(0);
+      CRYPT_MD5Update(md5, (uint8_t*)id.c_str(), id.GetLength());
+    }
+    uint8_t digest[32];
+    CRYPT_MD5Finish(md5, digest);
+    CRYPT_ArcFourCryptBlock(digest, 16, m_EncryptKey, key_len);
+    uint8_t tempkey[32];
+    for (int i = 1; i <= 19; i++) {
+      for (int j = 0; j < key_len; j++) {
+        tempkey[j] = m_EncryptKey[j] ^ (uint8_t)i;
+      }
+      CRYPT_ArcFourCryptBlock(digest, 16, tempkey, key_len);
+    }
+    CRYPT_MD5Generate(digest, 16, digest + 16);
+    pEncryptDict->SetAtString("U", CFX_ByteString(digest, 32));
+  }
+}
+void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict,
+                                            CPDF_Array* pIdArray,
+                                            const uint8_t* user_pass,
+                                            FX_DWORD user_size,
+                                            const uint8_t* owner_pass,
+                                            FX_DWORD owner_size,
+                                            FX_DWORD type) {
+  OnCreate(pEncryptDict, pIdArray, user_pass, user_size, owner_pass, owner_size,
+           TRUE, type);
+}
+void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict,
+                                            CPDF_Array* pIdArray,
+                                            const uint8_t* user_pass,
+                                            FX_DWORD user_size,
+                                            FX_DWORD type) {
+  OnCreate(pEncryptDict, pIdArray, user_pass, user_size, NULL, 0, FALSE, type);
+}
+void CPDF_StandardSecurityHandler::AES256_SetPassword(
+    CPDF_Dictionary* pEncryptDict,
+    const uint8_t* password,
+    FX_DWORD size,
+    FX_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);
+  uint8_t digest[20];
+  CRYPT_SHA1Finish(sha, digest);
+  CFX_ByteString ukey = pEncryptDict->GetStringBy("U");
+  uint8_t digest1[48];
+  if (m_Revision >= 6) {
+    Revision6_Hash(password, size, digest,
+                   (bOwner ? (const uint8_t*)ukey : NULL), digest1);
+  } else {
+    CRYPT_SHA256Start(sha);
+    CRYPT_SHA256Update(sha, password, size);
+    CRYPT_SHA256Update(sha, digest, 8);
+    if (bOwner) {
+      CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
+    }
+    CRYPT_SHA256Finish(sha, digest1);
+  }
+  FXSYS_memcpy(digest1 + 32, digest, 16);
+  pEncryptDict->SetAtString(bOwner ? "O" : "U", CFX_ByteString(digest1, 48));
+  if (m_Revision >= 6) {
+    Revision6_Hash(password, size, digest + 8,
+                   (bOwner ? (const uint8_t*)ukey : NULL), digest1);
+  } else {
+    CRYPT_SHA256Start(sha);
+    CRYPT_SHA256Update(sha, password, size);
+    CRYPT_SHA256Update(sha, digest + 8, 8);
+    if (bOwner) {
+      CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
+    }
+    CRYPT_SHA256Finish(sha, 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->SetAtString(bOwner ? "OE" : "UE", CFX_ByteString(digest1, 32));
+}
+void CPDF_StandardSecurityHandler::AES256_SetPerms(
+    CPDF_Dictionary* pEncryptDict,
+    FX_DWORD permissions,
+    FX_BOOL bEncryptMetadata,
+    const uint8_t* key) {
+  uint8_t buf[16];
+  buf[0] = (uint8_t)permissions;
+  buf[1] = (uint8_t)(permissions >> 8);
+  buf[2] = (uint8_t)(permissions >> 16);
+  buf[3] = (uint8_t)(permissions >> 24);
+  buf[4] = 0xff;
+  buf[5] = 0xff;
+  buf[6] = 0xff;
+  buf[7] = 0xff;
+  buf[8] = bEncryptMetadata ? 'T' : 'F';
+  buf[9] = 'a';
+  buf[10] = 'd';
+  buf[11] = 'b';
+  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->SetAtString("Perms", CFX_ByteString(buf1, 16));
+}
diff --git a/core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.h b/core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.h
new file mode 100644
index 0000000000..27aeaa8bc0
--- /dev/null
+++ b/core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.h
@@ -0,0 +1,105 @@
+// Copyright 2016 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
+
+#ifndef CORE_SRC_FPDFAPI_FPDF_PARSER_CPDF_STANDARD_SECURITY_HANDLER_H_
+#define CORE_SRC_FPDFAPI_FPDF_PARSER_CPDF_STANDARD_SECURITY_HANDLER_H_
+
+#include "core/include/fpdfapi/ipdf_security_handler.h"
+#include "core/include/fxcrt/fx_string.h"
+#include "core/include/fxcrt/fx_system.h"
+
+class CPDF_Array;
+
+#define PDF_ENCRYPT_CONTENT 0
+
+class CPDF_StandardSecurityHandler : public IPDF_SecurityHandler {
+ public:
+  CPDF_StandardSecurityHandler();
+  ~CPDF_StandardSecurityHandler() override;
+
+  // IPDF_SecurityHandler:
+  FX_BOOL OnInit(CPDF_Parser* pParser, CPDF_Dictionary* pEncryptDict) override;
+  FX_DWORD GetPermissions() override;
+  FX_BOOL GetCryptInfo(int& cipher,
+                       const uint8_t*& buffer,
+                       int& keylen) override;
+  FX_BOOL IsMetadataEncrypted() override;
+  CPDF_CryptoHandler* CreateCryptoHandler() override;
+
+  void OnCreate(CPDF_Dictionary* pEncryptDict,
+                CPDF_Array* pIdArray,
+                const uint8_t* user_pass,
+                FX_DWORD user_size,
+                const uint8_t* owner_pass,
+                FX_DWORD owner_size,
+                FX_DWORD type = PDF_ENCRYPT_CONTENT);
+
+  void OnCreate(CPDF_Dictionary* pEncryptDict,
+                CPDF_Array* pIdArray,
+                const uint8_t* user_pass,
+                FX_DWORD user_size,
+                FX_DWORD type = PDF_ENCRYPT_CONTENT);
+
+  CFX_ByteString GetUserPassword(const uint8_t* owner_pass,
+                                 FX_DWORD pass_size,
+                                 int32_t key_len);
+  int CheckPassword(const uint8_t* password,
+                    FX_DWORD pass_size,
+                    FX_BOOL bOwner,
+                    uint8_t* key,
+                    int key_len);
+
+ private:
+  FX_BOOL LoadDict(CPDF_Dictionary* pEncryptDict);
+  FX_BOOL LoadDict(CPDF_Dictionary* pEncryptDict,
+                   FX_DWORD type,
+                   int& cipher,
+                   int& key_len);
+
+  FX_BOOL CheckUserPassword(const uint8_t* password,
+                            FX_DWORD pass_size,
+                            FX_BOOL bIgnoreEncryptMeta,
+                            uint8_t* key,
+                            int32_t key_len);
+
+  FX_BOOL CheckOwnerPassword(const uint8_t* password,
+                             FX_DWORD pass_size,
+                             uint8_t* key,
+                             int32_t key_len);
+  FX_BOOL AES256_CheckPassword(const uint8_t* password,
+                               FX_DWORD size,
+                               FX_BOOL bOwner,
+                               uint8_t* key);
+  void AES256_SetPassword(CPDF_Dictionary* pEncryptDict,
+                          const uint8_t* password,
+                          FX_DWORD size,
+                          FX_BOOL bOwner,
+                          const uint8_t* key);
+  void AES256_SetPerms(CPDF_Dictionary* pEncryptDict,
+                       FX_DWORD permission,
+                       FX_BOOL bEncryptMetadata,
+                       const uint8_t* key);
+  void OnCreate(CPDF_Dictionary* pEncryptDict,
+                CPDF_Array* pIdArray,
+                const uint8_t* user_pass,
+                FX_DWORD user_size,
+                const uint8_t* owner_pass,
+                FX_DWORD owner_size,
+                FX_BOOL bDefault,
+                FX_DWORD type);
+  FX_BOOL CheckSecurity(int32_t key_len);
+
+  int m_Version;
+  int m_Revision;
+  CPDF_Parser* m_pParser;
+  CPDF_Dictionary* m_pEncryptDict;
+  FX_DWORD m_Permissions;
+  int m_Cipher;
+  uint8_t m_EncryptKey[32];
+  int m_KeyLen;
+};
+
+#endif  // CORE_SRC_FPDFAPI_FPDF_PARSER_CPDF_STANDARD_SECURITY_HANDLER_H_
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp
index 9fe534ec35..acf7e11dca 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp
@@ -10,59 +10,9 @@
 
 #include "core/include/fpdfapi/cpdf_parser.h"
 #include "core/include/fpdfapi/cpdf_simple_parser.h"
+#include "core/include/fpdfapi/ipdf_security_handler.h"
 #include "core/include/fdrm/fx_crypt.h"
 
-const uint8_t defpasscode[32] = {
-    0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41, 0x64, 0x00, 0x4e,
-    0x56, 0xff, 0xfa, 0x01, 0x08, 0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68,
-    0x3e, 0x80, 0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a};
-void CalcEncryptKey(CPDF_Dictionary* pEncrypt,
-                    const uint8_t* password,
-                    FX_DWORD pass_size,
-                    uint8_t* key,
-                    int keylen,
-                    FX_BOOL bIgnoreMeta,
-                    CPDF_Array* pIdArray) {
-  int revision = pEncrypt->GetIntegerBy("R");
-  uint8_t passcode[32];
-  for (FX_DWORD i = 0; i < 32; i++) {
-    passcode[i] = i < pass_size ? password[i] : defpasscode[i - pass_size];
-  }
-  uint8_t md5[100];
-  CRYPT_MD5Start(md5);
-  CRYPT_MD5Update(md5, passcode, 32);
-  CFX_ByteString okey = pEncrypt->GetStringBy("O");
-  CRYPT_MD5Update(md5, (uint8_t*)okey.c_str(), okey.GetLength());
-  FX_DWORD perm = pEncrypt->GetIntegerBy("P");
-  CRYPT_MD5Update(md5, (uint8_t*)&perm, 4);
-  if (pIdArray) {
-    CFX_ByteString id = pIdArray->GetStringAt(0);
-    CRYPT_MD5Update(md5, (uint8_t*)id.c_str(), id.GetLength());
-  }
-  if (!bIgnoreMeta && revision >= 3 &&
-      !pEncrypt->GetIntegerBy("EncryptMetadata", 1)) {
-    FX_DWORD tag = (FX_DWORD)-1;
-    CRYPT_MD5Update(md5, (uint8_t*)&tag, 4);
-  }
-  uint8_t digest[16];
-  CRYPT_MD5Finish(md5, digest);
-  FX_DWORD copy_len = keylen;
-  if (copy_len > sizeof(digest)) {
-    copy_len = sizeof(digest);
-  }
-  if (revision >= 3) {
-    for (int i = 0; i < 50; i++) {
-      CRYPT_MD5Generate(digest, copy_len, digest);
-    }
-  }
-  FXSYS_memset(key, 0, keylen);
-  FXSYS_memcpy(key, digest, copy_len);
-}
-
-CPDF_CryptoHandler* CPDF_StandardSecurityHandler::CreateCryptoHandler() {
-  return new CPDF_StandardCryptoHandler;
-}
-
 struct PDF_CRYPTOITEM {
   int32_t m_Cipher;
   int32_t m_KeyLen;
@@ -70,648 +20,6 @@ struct PDF_CRYPTOITEM {
   CPDF_StandardCryptoHandler* m_pCryptoHandler;
 };
 
-CPDF_StandardSecurityHandler::CPDF_StandardSecurityHandler() {
-  m_Version = 0;
-  m_Revision = 0;
-  m_pParser = NULL;
-  m_pEncryptDict = NULL;
-  m_Permissions = 0;
-  m_Cipher = FXCIPHER_NONE;
-  m_KeyLen = 0;
-}
-
-CPDF_StandardSecurityHandler::~CPDF_StandardSecurityHandler() {}
-FX_BOOL CPDF_StandardSecurityHandler::OnInit(CPDF_Parser* pParser,
-                                             CPDF_Dictionary* pEncryptDict) {
-  m_pParser = pParser;
-  if (!LoadDict(pEncryptDict)) {
-    return FALSE;
-  }
-  if (m_Cipher == FXCIPHER_NONE) {
-    return TRUE;
-  }
-  return CheckSecurity(m_KeyLen);
-}
-FX_BOOL CPDF_StandardSecurityHandler::CheckSecurity(int32_t key_len) {
-  CFX_ByteString password = m_pParser->GetPassword();
-  if (CheckPassword(password, password.GetLength(), TRUE, m_EncryptKey,
-                    key_len)) {
-    if (password.IsEmpty()) {
-      if (!CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey,
-                         key_len)) {
-        return FALSE;
-      }
-    }
-    return TRUE;
-  }
-  return CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey,
-                       key_len);
-}
-FX_DWORD CPDF_StandardSecurityHandler::GetPermissions() {
-  return m_Permissions;
-}
-static FX_BOOL _LoadCryptInfo(CPDF_Dictionary* pEncryptDict,
-                              const CFX_ByteStringC& name,
-                              int& cipher,
-                              int& keylen) {
-  int Version = pEncryptDict->GetIntegerBy("V");
-  cipher = FXCIPHER_RC4;
-  keylen = 0;
-  if (Version >= 4) {
-    CPDF_Dictionary* pCryptFilters = pEncryptDict->GetDictBy("CF");
-    if (!pCryptFilters) {
-      return FALSE;
-    }
-    if (name == "Identity") {
-      cipher = FXCIPHER_NONE;
-    } else {
-      CPDF_Dictionary* pDefFilter = pCryptFilters->GetDictBy(name);
-      if (!pDefFilter) {
-        return FALSE;
-      }
-      int nKeyBits = 0;
-      if (Version == 4) {
-        nKeyBits = pDefFilter->GetIntegerBy("Length", 0);
-        if (nKeyBits == 0) {
-          nKeyBits = pEncryptDict->GetIntegerBy("Length", 128);
-        }
-      } else {
-        nKeyBits = pEncryptDict->GetIntegerBy("Length", 256);
-      }
-      if (nKeyBits < 40) {
-        nKeyBits *= 8;
-      }
-      keylen = nKeyBits / 8;
-      CFX_ByteString cipher_name = pDefFilter->GetStringBy("CFM");
-      if (cipher_name == "AESV2" || cipher_name == "AESV3") {
-        cipher = FXCIPHER_AES;
-      }
-    }
-  } else {
-    keylen = Version > 1 ? pEncryptDict->GetIntegerBy("Length", 40) / 8 : 5;
-  }
-  if (keylen > 32 || keylen < 0) {
-    return FALSE;
-  }
-  return TRUE;
-}
-
-FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict) {
-  m_pEncryptDict = pEncryptDict;
-  m_Version = pEncryptDict->GetIntegerBy("V");
-  m_Revision = pEncryptDict->GetIntegerBy("R");
-  m_Permissions = pEncryptDict->GetIntegerBy("P", -1);
-  if (m_Version < 4) {
-    return _LoadCryptInfo(pEncryptDict, CFX_ByteString(), m_Cipher, m_KeyLen);
-  }
-  CFX_ByteString stmf_name = pEncryptDict->GetStringBy("StmF");
-  CFX_ByteString strf_name = pEncryptDict->GetStringBy("StrF");
-  if (stmf_name != strf_name) {
-    return FALSE;
-  }
-  if (!_LoadCryptInfo(pEncryptDict, strf_name, m_Cipher, m_KeyLen)) {
-    return FALSE;
-  }
-  return TRUE;
-}
-
-FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict,
-                                               FX_DWORD type,
-                                               int& cipher,
-                                               int& key_len) {
-  m_pEncryptDict = pEncryptDict;
-  m_Version = pEncryptDict->GetIntegerBy("V");
-  m_Revision = pEncryptDict->GetIntegerBy("R");
-  m_Permissions = pEncryptDict->GetIntegerBy("P", -1);
-  CFX_ByteString strf_name, stmf_name;
-  if (m_Version >= 4) {
-    stmf_name = pEncryptDict->GetStringBy("StmF");
-    strf_name = pEncryptDict->GetStringBy("StrF");
-    if (stmf_name != strf_name) {
-      return FALSE;
-    }
-  }
-  if (!_LoadCryptInfo(pEncryptDict, strf_name, cipher, key_len)) {
-    return FALSE;
-  }
-  m_Cipher = cipher;
-  m_KeyLen = key_len;
-  return TRUE;
-}
-
-FX_BOOL CPDF_StandardSecurityHandler::GetCryptInfo(int& cipher,
-                                                   const uint8_t*& buffer,
-                                                   int& keylen) {
-  cipher = m_Cipher;
-  buffer = m_EncryptKey;
-  keylen = m_KeyLen;
-  return TRUE;
-}
-#define FX_GET_32WORD(n, b, i)                                        \
-  {                                                                   \
-    (n) = (FX_DWORD)(                                                 \
-        ((uint64_t)(b)[(i)] << 24) | ((uint64_t)(b)[(i) + 1] << 16) | \
-        ((uint64_t)(b)[(i) + 2] << 8) | ((uint64_t)(b)[(i) + 3]));    \
-  }
-int BigOrder64BitsMod3(uint8_t* data) {
-  uint64_t ret = 0;
-  for (int i = 0; i < 4; ++i) {
-    FX_DWORD value;
-    FX_GET_32WORD(value, data, 4 * i);
-    ret <<= 32;
-    ret |= value;
-    ret %= 3;
-  }
-  return (int)ret;
-}
-void Revision6_Hash(const uint8_t* password,
-                    FX_DWORD 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);
-  }
-  uint8_t digest[32];
-  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;
-  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;
-    for (int j = 0; j < 64; ++j) {
-      content.AppendBlock(password, size);
-      content.AppendBlock(input, iBlockSize);
-      if (vector) {
-        content.AppendBlock(vector, 48);
-      }
-    }
-    CRYPT_AESSetKey(aes, 16, key, 16, TRUE);
-    CRYPT_AESSetIV(aes, iv);
-    CRYPT_AESEncrypt(aes, E, content.GetBuffer(), iBufLen);
-    int iHash = 0;
-    switch (BigOrder64BitsMod3(E)) {
-      case 0:
-        iHash = 0;
-        iBlockSize = 32;
-        break;
-      case 1:
-        iHash = 1;
-        iBlockSize = 48;
-        break;
-      default:
-        iHash = 2;
-        iBlockSize = 64;
-        break;
-    }
-    interDigest.EstimateSize(iBlockSize);
-    input = interDigest.GetBuffer();
-    if (iHash == 0) {
-      CRYPT_SHA256Generate(E, iBufLen, input);
-    } else if (iHash == 1) {
-      CRYPT_SHA384Generate(E, iBufLen, input);
-    } else if (iHash == 2) {
-      CRYPT_SHA512Generate(E, iBufLen, input);
-    }
-    key = input;
-    iv = input + 16;
-    ++i;
-  }
-  FX_Free(aes);
-  if (hash) {
-    FXSYS_memcpy(hash, input, 32);
-  }
-}
-FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(
-    const uint8_t* password,
-    FX_DWORD size,
-    FX_BOOL bOwner,
-    uint8_t* key) {
-  CFX_ByteString okey =
-      m_pEncryptDict ? m_pEncryptDict->GetStringBy("O") : CFX_ByteString();
-  if (okey.GetLength() < 48) {
-    return FALSE;
-  }
-  CFX_ByteString ukey =
-      m_pEncryptDict ? m_pEncryptDict->GetStringBy("U") : CFX_ByteString();
-  if (ukey.GetLength() < 48) {
-    return FALSE;
-  }
-  const uint8_t* pkey = bOwner ? (const uint8_t*)okey : (const uint8_t*)ukey;
-  uint8_t sha[128];
-  uint8_t digest[32];
-  if (m_Revision >= 6) {
-    Revision6_Hash(password, size, (const uint8_t*)pkey + 32,
-                   (bOwner ? (const uint8_t*)ukey : NULL), digest);
-  } else {
-    CRYPT_SHA256Start(sha);
-    CRYPT_SHA256Update(sha, password, size);
-    CRYPT_SHA256Update(sha, pkey + 32, 8);
-    if (bOwner) {
-      CRYPT_SHA256Update(sha, ukey, 48);
-    }
-    CRYPT_SHA256Finish(sha, digest);
-  }
-  if (FXSYS_memcmp(digest, pkey, 32) != 0) {
-    return FALSE;
-  }
-  if (!key) {
-    return TRUE;
-  }
-  if (m_Revision >= 6) {
-    Revision6_Hash(password, size, (const uint8_t*)pkey + 40,
-                   (bOwner ? (const uint8_t*)ukey : NULL), digest);
-  } else {
-    CRYPT_SHA256Start(sha);
-    CRYPT_SHA256Update(sha, password, size);
-    CRYPT_SHA256Update(sha, pkey + 40, 8);
-    if (bOwner) {
-      CRYPT_SHA256Update(sha, ukey, 48);
-    }
-    CRYPT_SHA256Finish(sha, digest);
-  }
-  CFX_ByteString ekey = m_pEncryptDict
-                            ? m_pEncryptDict->GetStringBy(bOwner ? "OE" : "UE")
-                            : CFX_ByteString();
-  if (ekey.GetLength() < 32) {
-    return FALSE;
-  }
-  uint8_t* aes = FX_Alloc(uint8_t, 2048);
-  CRYPT_AESSetKey(aes, 16, digest, 32, FALSE);
-  uint8_t iv[16];
-  FXSYS_memset(iv, 0, 16);
-  CRYPT_AESSetIV(aes, iv);
-  CRYPT_AESDecrypt(aes, key, ekey, 32);
-  CRYPT_AESSetKey(aes, 16, key, 32, FALSE);
-  CRYPT_AESSetIV(aes, iv);
-  CFX_ByteString perms = m_pEncryptDict->GetStringBy("Perms");
-  if (perms.IsEmpty()) {
-    return FALSE;
-  }
-  uint8_t perms_buf[16];
-  FXSYS_memset(perms_buf, 0, sizeof(perms_buf));
-  FX_DWORD copy_len = sizeof(perms_buf);
-  if (copy_len > (FX_DWORD)perms.GetLength()) {
-    copy_len = perms.GetLength();
-  }
-  FXSYS_memcpy(perms_buf, (const uint8_t*)perms, copy_len);
-  uint8_t buf[16];
-  CRYPT_AESDecrypt(aes, buf, perms_buf, 16);
-  FX_Free(aes);
-  if (buf[9] != 'a' || buf[10] != 'd' || buf[11] != 'b') {
-    return FALSE;
-  }
-  if (FXDWORD_GET_LSBFIRST(buf) != m_Permissions) {
-    return FALSE;
-  }
-  if ((buf[8] == 'T' && !IsMetadataEncrypted()) ||
-      (buf[8] == 'F' && IsMetadataEncrypted())) {
-    return FALSE;
-  }
-  return TRUE;
-}
-
-int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password,
-                                                FX_DWORD size,
-                                                FX_BOOL bOwner,
-                                                uint8_t* key,
-                                                int32_t key_len) {
-  if (m_Revision >= 5) {
-    return AES256_CheckPassword(password, size, bOwner, key);
-  }
-  uint8_t keybuf[32];
-  if (!key) {
-    key = keybuf;
-  }
-  if (bOwner) {
-    return CheckOwnerPassword(password, size, key, key_len);
-  }
-  return CheckUserPassword(password, size, FALSE, key, key_len) ||
-         CheckUserPassword(password, size, TRUE, key, key_len);
-}
-FX_BOOL CPDF_StandardSecurityHandler::CheckUserPassword(
-    const uint8_t* password,
-    FX_DWORD pass_size,
-    FX_BOOL bIgnoreEncryptMeta,
-    uint8_t* key,
-    int32_t key_len) {
-  CalcEncryptKey(m_pEncryptDict, password, pass_size, key, key_len,
-                 bIgnoreEncryptMeta, m_pParser->GetIDArray());
-  CFX_ByteString ukey =
-      m_pEncryptDict ? m_pEncryptDict->GetStringBy("U") : CFX_ByteString();
-  if (ukey.GetLength() < 16) {
-    return FALSE;
-  }
-  uint8_t ukeybuf[32];
-  if (m_Revision == 2) {
-    FXSYS_memcpy(ukeybuf, defpasscode, 32);
-    CRYPT_ArcFourCryptBlock(ukeybuf, 32, key, key_len);
-  } else {
-    uint8_t test[32], tmpkey[32];
-    FX_DWORD copy_len = sizeof(test);
-    if (copy_len > (FX_DWORD)ukey.GetLength()) {
-      copy_len = ukey.GetLength();
-    }
-    FXSYS_memset(test, 0, sizeof(test));
-    FXSYS_memset(tmpkey, 0, sizeof(tmpkey));
-    FXSYS_memcpy(test, ukey.c_str(), copy_len);
-    for (int i = 19; i >= 0; i--) {
-      for (int j = 0; j < key_len; j++) {
-        tmpkey[j] = key[j] ^ i;
-      }
-      CRYPT_ArcFourCryptBlock(test, 32, tmpkey, key_len);
-    }
-    uint8_t md5[100];
-    CRYPT_MD5Start(md5);
-    CRYPT_MD5Update(md5, defpasscode, 32);
-    CPDF_Array* pIdArray = m_pParser->GetIDArray();
-    if (pIdArray) {
-      CFX_ByteString id = pIdArray->GetStringAt(0);
-      CRYPT_MD5Update(md5, (uint8_t*)id.c_str(), id.GetLength());
-    }
-    CRYPT_MD5Finish(md5, ukeybuf);
-    return FXSYS_memcmp(test, ukeybuf, 16) == 0;
-  }
-  if (FXSYS_memcmp((void*)ukey.c_str(), ukeybuf, 16) == 0) {
-    return TRUE;
-  }
-  return FALSE;
-}
-CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(
-    const uint8_t* owner_pass,
-    FX_DWORD pass_size,
-    int32_t key_len) {
-  CFX_ByteString okey = m_pEncryptDict->GetStringBy("O");
-  uint8_t passcode[32];
-  FX_DWORD i;
-  for (i = 0; i < 32; i++) {
-    passcode[i] = i < pass_size ? owner_pass[i] : defpasscode[i - pass_size];
-  }
-  uint8_t digest[16];
-  CRYPT_MD5Generate(passcode, 32, digest);
-  if (m_Revision >= 3) {
-    for (int i = 0; i < 50; i++) {
-      CRYPT_MD5Generate(digest, 16, digest);
-    }
-  }
-  uint8_t enckey[32];
-  FXSYS_memset(enckey, 0, sizeof(enckey));
-  FX_DWORD copy_len = key_len;
-  if (copy_len > sizeof(digest)) {
-    copy_len = sizeof(digest);
-  }
-  FXSYS_memcpy(enckey, digest, copy_len);
-  int okeylen = okey.GetLength();
-  if (okeylen > 32) {
-    okeylen = 32;
-  }
-  uint8_t okeybuf[64];
-  FXSYS_memset(okeybuf, 0, sizeof(okeybuf));
-  FXSYS_memcpy(okeybuf, okey.c_str(), okeylen);
-  if (m_Revision == 2) {
-    CRYPT_ArcFourCryptBlock(okeybuf, okeylen, enckey, key_len);
-  } else {
-    for (int i = 19; i >= 0; i--) {
-      uint8_t tempkey[32];
-      FXSYS_memset(tempkey, 0, sizeof(tempkey));
-      for (int j = 0; j < m_KeyLen; j++) {
-        tempkey[j] = enckey[j] ^ i;
-      }
-      CRYPT_ArcFourCryptBlock(okeybuf, okeylen, tempkey, key_len);
-    }
-  }
-  int len = 32;
-  while (len && defpasscode[len - 1] == okeybuf[len - 1]) {
-    len--;
-  }
-  return CFX_ByteString(okeybuf, len);
-}
-FX_BOOL CPDF_StandardSecurityHandler::CheckOwnerPassword(
-    const uint8_t* password,
-    FX_DWORD pass_size,
-    uint8_t* key,
-    int32_t key_len) {
-  CFX_ByteString user_pass = GetUserPassword(password, pass_size, key_len);
-  if (CheckUserPassword(user_pass, user_pass.GetLength(), FALSE, key,
-                        key_len)) {
-    return TRUE;
-  }
-  return CheckUserPassword(user_pass, user_pass.GetLength(), TRUE, key,
-                           key_len);
-}
-FX_BOOL CPDF_StandardSecurityHandler::IsMetadataEncrypted() {
-  return m_pEncryptDict->GetBooleanBy("EncryptMetadata", TRUE);
-}
-
-IPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler() {
-  return new CPDF_StandardSecurityHandler;
-}
-
-void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict,
-                                            CPDF_Array* pIdArray,
-                                            const uint8_t* user_pass,
-                                            FX_DWORD user_size,
-                                            const uint8_t* owner_pass,
-                                            FX_DWORD owner_size,
-                                            FX_BOOL bDefault,
-                                            FX_DWORD type) {
-  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(NULL);
-    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);
-    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->GetBooleanBy("EncryptMetadata", TRUE),
-                      m_EncryptKey);
-    }
-    return;
-  }
-  if (bDefault) {
-    uint8_t passcode[32];
-    FX_DWORD i;
-    for (i = 0; i < 32; i++) {
-      passcode[i] =
-          i < owner_size ? owner_pass[i] : defpasscode[i - owner_size];
-    }
-    uint8_t digest[16];
-    CRYPT_MD5Generate(passcode, 32, digest);
-    if (m_Revision >= 3) {
-      for (int i = 0; i < 50; i++) {
-        CRYPT_MD5Generate(digest, 16, digest);
-      }
-    }
-    uint8_t enckey[32];
-    FXSYS_memcpy(enckey, digest, key_len);
-    for (i = 0; i < 32; i++) {
-      passcode[i] = i < user_size ? user_pass[i] : defpasscode[i - user_size];
-    }
-    CRYPT_ArcFourCryptBlock(passcode, 32, enckey, key_len);
-    uint8_t tempkey[32];
-    if (m_Revision >= 3) {
-      for (i = 1; i <= 19; i++) {
-        for (int j = 0; j < key_len; j++) {
-          tempkey[j] = enckey[j] ^ (uint8_t)i;
-        }
-        CRYPT_ArcFourCryptBlock(passcode, 32, tempkey, key_len);
-      }
-    }
-    pEncryptDict->SetAtString("O", CFX_ByteString(passcode, 32));
-  }
-  CalcEncryptKey(m_pEncryptDict, (uint8_t*)user_pass, user_size, m_EncryptKey,
-                 key_len, FALSE, pIdArray);
-  if (m_Revision < 3) {
-    uint8_t tempbuf[32];
-    FXSYS_memcpy(tempbuf, defpasscode, 32);
-    CRYPT_ArcFourCryptBlock(tempbuf, 32, m_EncryptKey, key_len);
-    pEncryptDict->SetAtString("U", CFX_ByteString(tempbuf, 32));
-  } else {
-    uint8_t md5[100];
-    CRYPT_MD5Start(md5);
-    CRYPT_MD5Update(md5, defpasscode, 32);
-    if (pIdArray) {
-      CFX_ByteString id = pIdArray->GetStringAt(0);
-      CRYPT_MD5Update(md5, (uint8_t*)id.c_str(), id.GetLength());
-    }
-    uint8_t digest[32];
-    CRYPT_MD5Finish(md5, digest);
-    CRYPT_ArcFourCryptBlock(digest, 16, m_EncryptKey, key_len);
-    uint8_t tempkey[32];
-    for (int i = 1; i <= 19; i++) {
-      for (int j = 0; j < key_len; j++) {
-        tempkey[j] = m_EncryptKey[j] ^ (uint8_t)i;
-      }
-      CRYPT_ArcFourCryptBlock(digest, 16, tempkey, key_len);
-    }
-    CRYPT_MD5Generate(digest, 16, digest + 16);
-    pEncryptDict->SetAtString("U", CFX_ByteString(digest, 32));
-  }
-}
-void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict,
-                                            CPDF_Array* pIdArray,
-                                            const uint8_t* user_pass,
-                                            FX_DWORD user_size,
-                                            const uint8_t* owner_pass,
-                                            FX_DWORD owner_size,
-                                            FX_DWORD type) {
-  OnCreate(pEncryptDict, pIdArray, user_pass, user_size, owner_pass, owner_size,
-           TRUE, type);
-}
-void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict,
-                                            CPDF_Array* pIdArray,
-                                            const uint8_t* user_pass,
-                                            FX_DWORD user_size,
-                                            FX_DWORD type) {
-  OnCreate(pEncryptDict, pIdArray, user_pass, user_size, NULL, 0, FALSE, type);
-}
-void CPDF_StandardSecurityHandler::AES256_SetPassword(
-    CPDF_Dictionary* pEncryptDict,
-    const uint8_t* password,
-    FX_DWORD size,
-    FX_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);
-  uint8_t digest[20];
-  CRYPT_SHA1Finish(sha, digest);
-  CFX_ByteString ukey = pEncryptDict->GetStringBy("U");
-  uint8_t digest1[48];
-  if (m_Revision >= 6) {
-    Revision6_Hash(password, size, digest,
-                   (bOwner ? (const uint8_t*)ukey : NULL), digest1);
-  } else {
-    CRYPT_SHA256Start(sha);
-    CRYPT_SHA256Update(sha, password, size);
-    CRYPT_SHA256Update(sha, digest, 8);
-    if (bOwner) {
-      CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
-    }
-    CRYPT_SHA256Finish(sha, digest1);
-  }
-  FXSYS_memcpy(digest1 + 32, digest, 16);
-  pEncryptDict->SetAtString(bOwner ? "O" : "U", CFX_ByteString(digest1, 48));
-  if (m_Revision >= 6) {
-    Revision6_Hash(password, size, digest + 8,
-                   (bOwner ? (const uint8_t*)ukey : NULL), digest1);
-  } else {
-    CRYPT_SHA256Start(sha);
-    CRYPT_SHA256Update(sha, password, size);
-    CRYPT_SHA256Update(sha, digest + 8, 8);
-    if (bOwner) {
-      CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
-    }
-    CRYPT_SHA256Finish(sha, 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->SetAtString(bOwner ? "OE" : "UE", CFX_ByteString(digest1, 32));
-}
-void CPDF_StandardSecurityHandler::AES256_SetPerms(
-    CPDF_Dictionary* pEncryptDict,
-    FX_DWORD permissions,
-    FX_BOOL bEncryptMetadata,
-    const uint8_t* key) {
-  uint8_t buf[16];
-  buf[0] = (uint8_t)permissions;
-  buf[1] = (uint8_t)(permissions >> 8);
-  buf[2] = (uint8_t)(permissions >> 16);
-  buf[3] = (uint8_t)(permissions >> 24);
-  buf[4] = 0xff;
-  buf[5] = 0xff;
-  buf[6] = 0xff;
-  buf[7] = 0xff;
-  buf[8] = bEncryptMetadata ? 'T' : 'F';
-  buf[9] = 'a';
-  buf[10] = 'd';
-  buf[11] = 'b';
-  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->SetAtString("Perms", CFX_ByteString(buf1, 16));
-}
 void CPDF_StandardCryptoHandler::CryptBlock(FX_BOOL bEncrypt,
                                             FX_DWORD objnum,
                                             FX_DWORD gennum,
diff --git a/pdfium.gyp b/pdfium.gyp
index c1e05412eb..1193066b52 100644
--- a/pdfium.gyp
+++ b/pdfium.gyp
@@ -262,6 +262,7 @@
         'core/include/fpdfapi/fpdf_render.h',
         'core/include/fpdfapi/fpdf_resource.h',
         'core/include/fpdfapi/fpdf_serial.h',
+        'core/include/fpdfapi/ipdf_security_handler.h',
         'core/src/fpdfapi/fpdf_basic_module.cpp',
         'core/src/fpdfapi/fpdf_cmaps/cmap_int.h',
         'core/src/fpdfapi/fpdf_cmaps/CNS1/Adobe-CNS1-UCS2_5.cpp',
@@ -351,6 +352,8 @@
         'core/src/fpdfapi/fpdf_parser/cpdf_document.cpp',
         'core/src/fpdfapi/fpdf_parser/cpdf_parser.cpp',
         'core/src/fpdfapi/fpdf_parser/cpdf_simple_parser.cpp',
+        'core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.cpp',
+        'core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.h',
         'core/src/fpdfapi/fpdf_parser/cpdf_syntax_parser.cpp',
         'core/src/fpdfapi/fpdf_parser/cpdf_syntax_parser.h',
         'core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp',