Push preg_parser changes upstream

components/policy/core/common/preg_parser.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/policy/core/common/preg_parser.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
+#include <limits>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 23 matching lines @@
 #define REG_RESOURCE_REQUIREMENTS_LIST 10
 #define REG_QWORD_LITTLE_ENDIAN 11
 #endif
 
 using RegistryDict = policy::RegistryDict;
 
 namespace {
 
 // Maximum PReg file size we're willing to accept.
 const int64_t kMaxPRegFileSize = 1024 * 1024 * 16;
+static_assert(kMaxPRegFileSize <= std::numeric_limits<ptrdiff_t>::max(),
+              "Max PReg file size too large.");
 
 // Constants for PReg file delimiters.
 const base::char16 kDelimBracketOpen = L'[';
 const base::char16 kDelimBracketClose = L']';
 const base::char16 kDelimSemicolon = L';';
 
 // Registry path separator.
 const base::string16 kRegistryPathSeparator = base::ASCIIToUTF16("\\");
 
 // Magic strings for the PReg value field to trigger special actions.
 const char kActionTriggerPrefix[] = "**";
 const char kActionTriggerDeleteValues[] = "deletevalues";
 const char kActionTriggerDel[] = "del.";
 const char kActionTriggerDelVals[] = "delvals";
 const char kActionTriggerDeleteKeys[] = "deletekeys";
 const char kActionTriggerSecureKey[] = "securekey";
 const char kActionTriggerSoft[] = "soft";
 
 // Returns the character at |cursor| and increments it, unless the end is here
-// in which case -1 is returned.
+// in which case -1 is returned. The calling code must guarantee that
+// end - *cursor does not overflow ptrdiff_t.
 int NextChar(const uint8_t** cursor, const uint8_t* end) {
   // Only read the character if a full base::char16 is available.
   // This comparison makes sure no overflow can happen.
   if (*cursor >= end ||
-      static_cast<size_t>(end - *cursor) < sizeof(base::char16))
+      end - *cursor < static_cast<ptrdiff_t>(sizeof(base::char16)))
     return -1;
 
   int result = **cursor | (*(*cursor + 1) << 8);
   *cursor += sizeof(base::char16);
   return result;
 }
 
-// Reads a fixed-size field from a PReg file.
+// Reads a fixed-size field from a PReg file. The calling code must guarantee
+// that both end - *cursor and size do not overflow ptrdiff_t.
 bool ReadFieldBinary(const uint8_t** cursor,
                      const uint8_t* end,
                      uint32_t size,
                      uint8_t* data) {
   if (size == 0)
     return true;
 
   // Be careful to prevent possible overflows here (don't do *cursor + size).
-  if (*cursor >= end || static_cast<size_t>(end - *cursor) < size)
+  if (*cursor >= end || end - *cursor < static_cast<ptrdiff_t>(size))
     return false;
   const uint8_t* field_end = *cursor + size;
   std::copy(*cursor, field_end, data);
   *cursor = field_end;
   return true;
 }
 
 bool ReadField32(const uint8_t** cursor, const uint8_t* end, uint32_t* data) {
   uint32_t value = 0;
   if (!ReadFieldBinary(cursor, end, sizeof(uint32_t),
@@ skipping 230 matching lines @@
 
   LOG(ERROR) << "Error parsing " << file_path.value() << " at offset "
              << reinterpret_cast<const uint8_t*>(cursor - 1) -
                     mapped_file.data();
   status->Add(POLICY_LOAD_STATUS_PARSE_ERROR);
   return false;
 }
 
 }  // namespace preg_parser
 }  // namespace policy