Make converstion explicit from CFX_ByteString to uint8_t*

core/fpdfapi/fpdf_parser/cpdf_standard_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/fpdf_parser/cpdf_standard_security_handler.h"
 
 #include <time.h>
 
@@ skipping 80 matching lines @@
   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 (CheckPassword(password.raw_str(), password.GetLength(), TRUE,
+                    m_EncryptKey, key_len)) {
     if (password.IsEmpty()) {
-      if (!CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey,
-                         key_len)) {
+      if (!CheckPassword(password.raw_str(), password.GetLength(), FALSE,
+                         m_EncryptKey, key_len)) {
         return FALSE;
       }
     }
     return TRUE;
   }
-  return CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey,
-                       key_len);
+  return CheckPassword(password.raw_str(), password.GetLength(), FALSE,
+                       m_EncryptKey, key_len);
 }
 uint32_t 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;
@@ skipping 190 matching lines @@
   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;
+  const uint8_t* pkey = (bOwner ? okey : ukey).raw_str();
   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);
+                   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, 48);
+      CRYPT_SHA256Update(sha, ukey.raw_str(), 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);
+                   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, 48);
+      CRYPT_SHA256Update(sha, ukey.raw_str(), 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_AESDecrypt(aes, key, ekey.raw_str(), 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));
   uint32_t copy_len = sizeof(perms_buf);
   if (copy_len > (uint32_t)perms.GetLength()) {
     copy_len = perms.GetLength();
   }
-  FXSYS_memcpy(perms_buf, (const uint8_t*)perms, copy_len);
+  FXSYS_memcpy(perms_buf, perms.raw_str(), 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()) ||
@@ skipping 117 matching lines @@
     len--;
   }
   return CFX_ByteString(okeybuf, len);
 }
 FX_BOOL CPDF_StandardSecurityHandler::CheckOwnerPassword(
     const uint8_t* password,
     uint32_t 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,
+  if (CheckUserPassword(user_pass.raw_str(), user_pass.GetLength(), FALSE, key,
                         key_len)) {
     return TRUE;
   }
-  return CheckUserPassword(user_pass, user_pass.GetLength(), TRUE, key,
-                           key_len);
+  return CheckUserPassword(user_pass.raw_str(), 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,
                                             uint32_t user_size,
                                             const uint8_t* owner_pass,
@@ skipping 111 matching lines @@
     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);
+    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);
     if (bOwner) {
-      CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
+      CRYPT_SHA256Update(sha, ukey.raw_str(), 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);
+                   bOwner ? ukey.raw_str() : nullptr, 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_SHA256Update(sha, ukey.raw_str(), 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);
@@ skipping 19 matching lines @@
   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));
 }