Remove IPDF_CryptoHandler and IPDF_SecurityHandler.

core/fpdfapi/fpdf_parser/cpdf_crypto_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/fpdf_parser/cpdf_standard_crypto_handler.h"
+#include "core/fpdfapi/fpdf_parser/cpdf_crypto_handler.h"
 
 #include <time.h>
 
 #include "core/fdrm/crypto/include/fx_crypt.h"
+#include "core/fpdfapi/fpdf_parser/cpdf_security_handler.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_parser.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_simple_parser.h"
-#include "core/fpdfapi/fpdf_parser/ipdf_security_handler.h"
 
-IPDF_CryptoHandler::~IPDF_CryptoHandler() {}
-
-void IPDF_CryptoHandler::Decrypt(uint32_t objnum,
-                                 uint32_t gennum,
-                                 CFX_ByteString& str) {
-  CFX_BinaryBuf dest_buf;
-  void* context = DecryptStart(objnum, gennum);
-  DecryptStream(context, str.raw_str(), str.GetLength(), dest_buf);
-  DecryptFinish(context, dest_buf);
-  str = CFX_ByteString(dest_buf.GetBuffer(), dest_buf.GetSize());
-}
-
-void CPDF_StandardCryptoHandler::CryptBlock(FX_BOOL bEncrypt,
-                                            uint32_t objnum,
-                                            uint32_t gennum,
-                                            const uint8_t* src_buf,
-                                            uint32_t src_size,
-                                            uint8_t* dest_buf,
-                                            uint32_t& dest_size) {
+void CPDF_CryptoHandler::CryptBlock(FX_BOOL bEncrypt,
+                                    uint32_t objnum,
+                                    uint32_t gennum,
+                                    const uint8_t* src_buf,
+                                    uint32_t src_size,
+                                    uint8_t* dest_buf,
+                                    uint32_t& dest_size) {
   if (m_Cipher == FXCIPHER_NONE) {
     FXSYS_memcpy(dest_buf, src_buf, src_size);
     return;
   }
   uint8_t realkey[16];
   int realkeylen = 16;
   if (m_Cipher != FXCIPHER_AES || m_KeyLen != 32) {
     uint8_t key1[32];
     FXSYS_memcpy(key1, m_EncryptKey, m_KeyLen);
     key1[m_KeyLen + 0] = (uint8_t)objnum;
@@ skipping 47 matching lines @@
   }
 }
 
 struct AESCryptContext {
   uint8_t m_Context[2048];
   FX_BOOL m_bIV;
   uint8_t m_Block[16];
   uint32_t m_BlockOffset;
 };
 
-void* CPDF_StandardCryptoHandler::CryptStart(uint32_t objnum,
-                                             uint32_t gennum,
-                                             FX_BOOL bEncrypt) {
+void* CPDF_CryptoHandler::CryptStart(uint32_t objnum,
+                                     uint32_t gennum,
+                                     FX_BOOL bEncrypt) {
   if (m_Cipher == FXCIPHER_NONE) {
     return this;
   }
   if (m_Cipher == FXCIPHER_AES && m_KeyLen == 32) {
     AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1);
     pContext->m_bIV = TRUE;
     pContext->m_BlockOffset = 0;
     CRYPT_AESSetKey(pContext->m_Context, 16, m_EncryptKey, 32, bEncrypt);
     if (bEncrypt) {
       for (int i = 0; i < 16; i++) {
@@ skipping 27 matching lines @@
         pContext->m_Block[i] = (uint8_t)rand();
       }
       CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block);
     }
     return pContext;
   }
   void* pContext = FX_Alloc(uint8_t, 1040);
   CRYPT_ArcFourSetup(pContext, realkey, realkeylen);
   return pContext;
 }
-FX_BOOL CPDF_StandardCryptoHandler::CryptStream(void* context,
-                                                const uint8_t* src_buf,
-                                                uint32_t src_size,
-                                                CFX_BinaryBuf& dest_buf,
-                                                FX_BOOL bEncrypt) {
+FX_BOOL CPDF_CryptoHandler::CryptStream(void* context,
+                                        const uint8_t* src_buf,
+                                        uint32_t src_size,
+                                        CFX_BinaryBuf& dest_buf,
+                                        FX_BOOL bEncrypt) {
   if (!context) {
     return FALSE;
   }
   if (m_Cipher == FXCIPHER_NONE) {
     dest_buf.AppendBlock(src_buf, src_size);
     return TRUE;
   }
   if (m_Cipher == FXCIPHER_RC4) {
     int old_size = dest_buf.GetSize();
     dest_buf.AppendBlock(src_buf, src_size);
@@ skipping 34 matching lines @@
         dest_buf.AppendBlock(block_buf, 16);
         pContext->m_BlockOffset = 0;
       }
     }
     if (!src_left) {
       break;
     }
   }
   return TRUE;
 }
-FX_BOOL CPDF_StandardCryptoHandler::CryptFinish(void* context,
-                                                CFX_BinaryBuf& dest_buf,
-                                                FX_BOOL bEncrypt) {
+FX_BOOL CPDF_CryptoHandler::CryptFinish(void* context,
+                                        CFX_BinaryBuf& dest_buf,
+                                        FX_BOOL bEncrypt) {
   if (!context) {
     return FALSE;
   }
   if (m_Cipher == FXCIPHER_NONE) {
     return TRUE;
   }
   if (m_Cipher == FXCIPHER_RC4) {
     FX_Free(context);
     return TRUE;
   }
@@ skipping 13 matching lines @@
   } else if (pContext->m_BlockOffset == 16) {
     uint8_t block_buf[16];
     CRYPT_AESDecrypt(pContext->m_Context, block_buf, pContext->m_Block, 16);
     if (block_buf[15] <= 16) {
       dest_buf.AppendBlock(block_buf, 16 - block_buf[15]);
     }
   }
   FX_Free(pContext);
   return TRUE;
 }
-void* CPDF_StandardCryptoHandler::DecryptStart(uint32_t objnum,
-                                               uint32_t gennum) {
+
+void CPDF_CryptoHandler::Decrypt(uint32_t objnum,
+                                 uint32_t gennum,
+                                 CFX_ByteString& str) {
+  CFX_BinaryBuf dest_buf;
+  void* context = DecryptStart(objnum, gennum);
+  DecryptStream(context, str.raw_str(), str.GetLength(), dest_buf);
+  DecryptFinish(context, dest_buf);
+  str = CFX_ByteString(dest_buf.GetBuffer(), dest_buf.GetSize());
+}
+
+void* CPDF_CryptoHandler::DecryptStart(uint32_t objnum, uint32_t gennum) {
   return CryptStart(objnum, gennum, FALSE);
 }
-uint32_t CPDF_StandardCryptoHandler::DecryptGetSize(uint32_t src_size) {
+uint32_t CPDF_CryptoHandler::DecryptGetSize(uint32_t src_size) {
   return m_Cipher == FXCIPHER_AES ? src_size - 16 : src_size;
 }
 
-FX_BOOL CPDF_StandardCryptoHandler::Init(
-    CPDF_Dictionary* pEncryptDict,
-    IPDF_SecurityHandler* pSecurityHandler) {
+FX_BOOL CPDF_CryptoHandler::Init(CPDF_Dictionary* pEncryptDict,
+                                 CPDF_SecurityHandler* pSecurityHandler) {
   const uint8_t* key;
   if (!pSecurityHandler->GetCryptInfo(m_Cipher, key, m_KeyLen)) {
     return FALSE;
   }
   if (m_KeyLen > 32 || m_KeyLen < 0) {
     return FALSE;
   }
   if (m_Cipher != FXCIPHER_NONE) {
     FXSYS_memcpy(m_EncryptKey, key, m_KeyLen);
   }
   if (m_Cipher == FXCIPHER_AES) {
     m_pAESContext = FX_Alloc(uint8_t, 2048);
   }
   return TRUE;
 }
 
-FX_BOOL CPDF_StandardCryptoHandler::Init(int cipher,
-                                         const uint8_t* key,
-                                         int keylen) {
+FX_BOOL CPDF_CryptoHandler::Init(int cipher, const uint8_t* key, int keylen) {
   if (cipher == FXCIPHER_AES) {
     switch (keylen) {
       case 16:
       case 24:
       case 32:
         break;
       default:
         return FALSE;
     }
   } else if (cipher == FXCIPHER_AES2) {
@@ skipping 10 matching lines @@
     }
   }
   m_Cipher = cipher;
   m_KeyLen = keylen;
   FXSYS_memcpy(m_EncryptKey, key, keylen);
   if (m_Cipher == FXCIPHER_AES) {
     m_pAESContext = FX_Alloc(uint8_t, 2048);
   }
   return TRUE;
 }
-FX_BOOL CPDF_StandardCryptoHandler::DecryptStream(void* context,
-                                                  const uint8_t* src_buf,
-                                                  uint32_t src_size,
-                                                  CFX_BinaryBuf& dest_buf) {
+FX_BOOL CPDF_CryptoHandler::DecryptStream(void* context,
+                                          const uint8_t* src_buf,
+                                          uint32_t src_size,
+                                          CFX_BinaryBuf& dest_buf) {
   return CryptStream(context, src_buf, src_size, dest_buf, FALSE);
 }
-FX_BOOL CPDF_StandardCryptoHandler::DecryptFinish(void* context,
-                                                  CFX_BinaryBuf& dest_buf) {
+FX_BOOL CPDF_CryptoHandler::DecryptFinish(void* context,
+                                          CFX_BinaryBuf& dest_buf) {
   return CryptFinish(context, dest_buf, FALSE);
 }
-uint32_t CPDF_StandardCryptoHandler::EncryptGetSize(uint32_t objnum,
-                                                    uint32_t version,
-                                                    const uint8_t* src_buf,
-                                                    uint32_t src_size) {
+uint32_t CPDF_CryptoHandler::EncryptGetSize(uint32_t objnum,
+                                            uint32_t version,
+                                            const uint8_t* src_buf,
+                                            uint32_t src_size) {
   if (m_Cipher == FXCIPHER_AES) {
     return src_size + 32;
   }
   return src_size;
 }
-FX_BOOL CPDF_StandardCryptoHandler::EncryptContent(uint32_t objnum,
-                                                   uint32_t gennum,
-                                                   const uint8_t* src_buf,
-                                                   uint32_t src_size,
-                                                   uint8_t* dest_buf,
-                                                   uint32_t& dest_size) {
+FX_BOOL CPDF_CryptoHandler::EncryptContent(uint32_t objnum,
+                                           uint32_t gennum,
+                                           const uint8_t* src_buf,
+                                           uint32_t src_size,
+                                           uint8_t* dest_buf,
+                                           uint32_t& dest_size) {
   CryptBlock(TRUE, objnum, gennum, src_buf, src_size, dest_buf, dest_size);
   return TRUE;
 }
-CPDF_StandardCryptoHandler::CPDF_StandardCryptoHandler() {
+CPDF_CryptoHandler::CPDF_CryptoHandler() {
   m_pAESContext = NULL;
   m_Cipher = FXCIPHER_NONE;
   m_KeyLen = 0;
 }
-CPDF_StandardCryptoHandler::~CPDF_StandardCryptoHandler() {
+CPDF_CryptoHandler::~CPDF_CryptoHandler() {
   FX_Free(m_pAESContext);
 }