Make CPDF_Object::GetString() a virtual method.

core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.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 <time.h>
 #include "../../../include/fpdfapi/fpdf_parser.h"
 #include "../../../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->GetInteger(FX_BSTRC("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->GetString(FX_BSTRC("O"));
+    CFX_ByteString okey = pEncrypt->GetStringAt("O");
     CRYPT_MD5Update(md5, (uint8_t*)okey.c_str(), okey.GetLength());
     FX_DWORD perm = pEncrypt->GetInteger(FX_BSTRC("P"));
     CRYPT_MD5Update(md5, (uint8_t*)&perm, 4);
     if (pIdArray) {
-        CFX_ByteString id = pIdArray->GetString(0);
+        CFX_ByteString id = pIdArray->GetStringAt(0);
         CRYPT_MD5Update(md5, (uint8_t*)id.c_str(), id.GetLength());
     }
     if (!bIgnoreMeta && revision >= 3 && !pEncrypt->GetInteger(FX_BSTRC("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)) {
@@ skipping 83 matching lines @@
                 if (nKeyBits == 0) {
                     nKeyBits = pEncryptDict->GetInteger(FX_BSTRC("Length"), 128);
                 }
             } else {
                 nKeyBits = pEncryptDict->GetInteger(FX_BSTRC("Length"), 256);
             }
             if (nKeyBits < 40) {
                 nKeyBits *= 8;
             }
             keylen = nKeyBits / 8;
-            CFX_ByteString cipher_name = pDefFilter->GetString(FX_BSTRC("CFM"));
+            CFX_ByteString cipher_name = pDefFilter->GetStringAt("CFM");
             if (cipher_name == FX_BSTRC("AESV2") || cipher_name == FX_BSTRC("AESV3")) {
                 cipher = FXCIPHER_AES;
             }
         }
     } else {
         keylen = Version > 1 ? pEncryptDict->GetInteger(FX_BSTRC("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_bOwner = FALSE;
     m_Version = pEncryptDict->GetInteger(FX_BSTRC("V"));
     m_Revision = pEncryptDict->GetInteger(FX_BSTRC("R"));
     m_Permissions = pEncryptDict->GetInteger(FX_BSTRC("P"), -1);
     if (m_Version < 4) {
         return _LoadCryptInfo(pEncryptDict, CFX_ByteString(), m_Cipher, m_KeyLen);
     }
-    CFX_ByteString stmf_name = pEncryptDict->GetString(FX_BSTRC("StmF"));
-    CFX_ByteString strf_name = pEncryptDict->GetString(FX_BSTRC("StrF"));
+    CFX_ByteString stmf_name = pEncryptDict->GetStringAt("StmF");
+    CFX_ByteString strf_name = pEncryptDict->GetStringAt("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_bOwner = FALSE;
     m_Version = pEncryptDict->GetInteger(FX_BSTRC("V"));
     m_Revision = pEncryptDict->GetInteger(FX_BSTRC("R"));
     m_Permissions = pEncryptDict->GetInteger(FX_BSTRC("P"), -1);
     CFX_ByteString strf_name, stmf_name;
     if (m_Version >= 4) {
-        stmf_name = pEncryptDict->GetString(FX_BSTRC("StmF"));
-        strf_name = pEncryptDict->GetString(FX_BSTRC("StrF"));
+        stmf_name = pEncryptDict->GetStringAt("StmF");
+        strf_name = pEncryptDict->GetStringAt("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;
@@ skipping 94 matching lines @@
         ++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->GetString(FX_BSTRC("O")) : CFX_ByteString();
+    CFX_ByteString okey = m_pEncryptDict ?
+        m_pEncryptDict->GetStringAt("O") : CFX_ByteString();
     if (okey.GetLength() < 48) {
         return FALSE;
     }
-    CFX_ByteString ukey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("U")) : CFX_ByteString();
+    CFX_ByteString ukey = m_pEncryptDict ?
+        m_pEncryptDict->GetStringAt("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);
@@ skipping 14 matching lines @@
         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->GetString(bOwner ? FX_BSTRC("OE") : FX_BSTRC("UE")) : CFX_ByteString();
+    CFX_ByteString ekey = m_pEncryptDict ?
+        m_pEncryptDict->GetStringAt(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->GetString(FX_BSTRC("Perms"));
+    CFX_ByteString perms = m_pEncryptDict->GetStringAt("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);
@@ skipping 27 matching lines @@
     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->GetString(FX_BSTRC("U")) : CFX_ByteString();
+    CFX_ByteString ukey = m_pEncryptDict ?
+        m_pEncryptDict->GetStringAt("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->GetString(0);
+            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)
 {
     return GetUserPassword(owner_pass, pass_size, m_KeyLen);
 }
 CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(const uint8_t* owner_pass, FX_DWORD pass_size, int32_t key_len)
 {
-    CFX_ByteString okey = m_pEncryptDict->GetString(FX_BSTRC("O"));
+    CFX_ByteString okey = m_pEncryptDict->GetStringAt("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);
@@ skipping 109 matching lines @@
     if (m_Revision < 3) {
         uint8_t tempbuf[32];
         FXSYS_memcpy(tempbuf, defpasscode, 32);
         CRYPT_ArcFourCryptBlock(tempbuf, 32, m_EncryptKey, key_len);
         pEncryptDict->SetAtString(FX_BSTRC("U"), CFX_ByteString(tempbuf, 32));
     } else {
         uint8_t md5[100];
         CRYPT_MD5Start(md5);
         CRYPT_MD5Update(md5, defpasscode, 32);
         if (pIdArray) {
-            CFX_ByteString id = pIdArray->GetString(0);
+            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;
             }
@@ skipping 14 matching lines @@
     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->GetString(FX_BSTRC("U"));
+    CFX_ByteString ukey = pEncryptDict->GetStringAt("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());
         }
@@ skipping 336 matching lines @@
     m_pAESContext = NULL;
     m_Cipher = FXCIPHER_NONE;
     m_KeyLen = 0;
 }
 CPDF_StandardCryptoHandler::~CPDF_StandardCryptoHandler()
 {
     if (m_pAESContext) {
         FX_Free(m_pAESContext);
     }
 }