Fix all the code which has duplicate variable declarations

core/fpdfapi/fpdf_parser/cpdf_security_handler.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fpdfapi/fpdf_parser/cpdf_security_handler.h"
 
 #include <time.h>
 
@@ skipping 412 matching lines @@
     CRYPT_ArcFourCryptBlock(ukeybuf, 32, key, key_len);
   } else {
     uint8_t test[32], tmpkey[32];
     uint32_t copy_len = sizeof(test);
     if (copy_len > (uint32_t)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++) {
+    uint8_t i = 19;
+    do {
+      for (int j = 0; j < key_len; j++)

[Tom Sepez, 2016/06/01 22:23:04]

probably a signed / unsigned comparison here, I'd make these int32_t's, leave
the existing loop logic, and static_cast to uint8_t before the xor.

Also below.

[Wei Li, 2016/06/01 23:40:12]

Done.

         tmpkey[j] = key[j] ^ i;
-      }
       CRYPT_ArcFourCryptBlock(test, 32, tmpkey, key_len);
-    }
+    } while (i-- > 0);
     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_SecurityHandler::GetUserPassword(const uint8_t* owner_pass,
                                                      uint32_t pass_size,
                                                      int32_t key_len) {
   CFX_ByteString okey = m_pEncryptDict->GetStringBy("O");
   uint8_t passcode[32];
-  uint32_t i;
-  for (i = 0; i < 32; i++) {
+  for (uint32_t 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++) {
+    for (uint32_t i = 0; i < 50; i++) {
       CRYPT_MD5Generate(digest, 16, digest);
     }
   }
   uint8_t enckey[32];
   FXSYS_memset(enckey, 0, sizeof(enckey));
   uint32_t 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 i = 19;
+    do {
       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);
-    }
+    } while (i-- > 0);
   }
   int len = 32;
   while (len && defpasscode[len - 1] == okeybuf[len - 1]) {
     len--;
   }
   return CFX_ByteString(okeybuf, len);
 }
 FX_BOOL CPDF_SecurityHandler::CheckOwnerPassword(const uint8_t* password,
                                                  uint32_t pass_size,
                                                  uint8_t* key,
@@ skipping 40 matching lines @@
       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];
-    uint32_t i;
-    for (i = 0; i < 32; i++) {
+    for (uint32_t 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++) {
+      for (uint32_t 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++) {
+    for (uint32_t 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;
-        }
+      for (uint8_t i = 1; i <= 19; i++) {
+        for (int j = 0; j < key_len; j++)
+          tempkey[j] = enckey[j] ^ 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 (uint8_t i = 1; i <= 19; i++) {
       for (int j = 0; j < key_len; j++) {
-        tempkey[j] = m_EncryptKey[j] ^ (uint8_t)i;
+        tempkey[j] = m_EncryptKey[j] ^ i;
       }
       CRYPT_ArcFourCryptBlock(digest, 16, tempkey, key_len);
     }
     CRYPT_MD5Generate(digest, 16, digest + 16);
     pEncryptDict->SetAtString("U", CFX_ByteString(digest, 32));
   }
 }
 void CPDF_SecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict,
                                     CPDF_Array* pIdArray,
                                     const uint8_t* user_pass,
@@ skipping 78 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));
 }