Revert of [gin] Unify snapshot loading on Windows and other platforms.

gin/v8_initializer.cc

 // Copyright 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 "gin/v8_initializer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 173 matching lines @@
 
 static const OpenedFileMap::mapped_type OpenFileIfNecessary(
     const char* file_name) {
   OpenedFileMap::mapped_type& opened = GetOpenedFile(file_name);
   if (opened.first == base::kInvalidPlatformFile) {
     opened.first = OpenV8File(file_name, &opened.second);
   }
   return opened;
 }
 
+#if defined(V8_VERIFY_EXTERNAL_STARTUP_DATA)
+bool VerifyV8StartupFile(base::MemoryMappedFile** file,
+                         const unsigned char* fingerprint) {
+  unsigned char output[crypto::kSHA256Length];
+  crypto::SHA256HashString(
+      base::StringPiece(reinterpret_cast<const char*>((*file)->data()),
+                        (*file)->length()),
+      output, sizeof(output));
+  if (!memcmp(fingerprint, output, sizeof(output))) {
+    return true;
+  }
+
+  // TODO(oth): Remove this temporary diagnostics for http://crbug.com/501799
+  uint64_t input[sizeof(output)];
+  memcpy(input, fingerprint, sizeof(input));
+
+  base::debug::Alias(output);
+  base::debug::Alias(input);
+
+  const uint64_t* o64 = reinterpret_cast<const uint64_t*>(output);
+  const uint64_t* f64 = reinterpret_cast<const uint64_t*>(fingerprint);
+  LOG(FATAL) << "Natives length " << (*file)->length()
+             << " H(computed) " << o64[0] << o64[1] << o64[2] << o64[3]
+             << " H(expected) " << f64[0] << f64[1] << f64[2] << f64[3];
+
+  delete *file;
+  *file = NULL;
+  return false;
+}
+#endif  // V8_VERIFY_EXTERNAL_STARTUP_DATA
 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
 
 bool GenerateEntropy(unsigned char* buffer, size_t amount) {
   base::RandBytes(buffer, amount);
   return true;
 }
 
 bool ShouldUseIgnition() {
   if (base::FeatureList::IsEnabled(features::kV8Ignition)) return true;
 #if defined(OS_ANDROID)
   if (base::FeatureList::IsEnabled(features::kV8IgnitionLowEnd) &&
       base::SysInfo::IsLowEndDevice()) {
     return true;
   }
 #endif
   return false;
 }
 
 
 }  // namespace
 
 #if defined(V8_USE_EXTERNAL_STARTUP_DATA)
-
-namespace {
+#if defined(V8_VERIFY_EXTERNAL_STARTUP_DATA)
+// Defined in gen/gin/v8_snapshot_fingerprint.cc
+extern const unsigned char g_natives_fingerprint[];
+extern const unsigned char g_snapshot_fingerprint[];
+#endif  // V8_VERIFY_EXTERNAL_STARTUP_DATA
 
 enum LoadV8FileResult {
   V8_LOAD_SUCCESS = 0,
   V8_LOAD_FAILED_OPEN,
   V8_LOAD_FAILED_MAP,
-  V8_LOAD_FAILED_VERIFY, // Deprecated.
+  V8_LOAD_FAILED_VERIFY,
   V8_LOAD_MAX_VALUE
 };
 
-LoadV8FileResult MapOpenedFile(
-    const OpenedFileMap::mapped_type& file_region,
-    base::MemoryMappedFile** mmapped_file_out) {
+static LoadV8FileResult MapVerify(const OpenedFileMap::mapped_type& file_region,
+#if defined(V8_VERIFY_EXTERNAL_STARTUP_DATA)
+                                  const unsigned char* fingerprint,
+#endif
+                                  base::MemoryMappedFile** mmapped_file_out) {
   if (file_region.first == base::kInvalidPlatformFile)
     return V8_LOAD_FAILED_OPEN;
   if (!MapV8File(file_region.first, file_region.second, mmapped_file_out))
     return V8_LOAD_FAILED_MAP;
+#if defined(V8_VERIFY_EXTERNAL_STARTUP_DATA)
+  if (!VerifyV8StartupFile(mmapped_file_out, fingerprint))
+    return V8_LOAD_FAILED_VERIFY;
+#endif  // V8_VERIFY_EXTERNAL_STARTUP_DATA
   return V8_LOAD_SUCCESS;
 }
 
-}  // namespace
-
 // static
 void V8Initializer::LoadV8Snapshot() {
   if (g_mapped_snapshot)
     return;
 
   OpenFileIfNecessary(kSnapshotFileName);
-  LoadV8FileResult result = MapOpenedFile(GetOpenedFile(kSnapshotFileName),
-                                          &g_mapped_snapshot);
+  LoadV8FileResult result = MapVerify(GetOpenedFile(kSnapshotFileName),
+#if defined(V8_VERIFY_EXTERNAL_STARTUP_DATA)
+                                      g_snapshot_fingerprint,
+#endif
+                                      &g_mapped_snapshot);
   // V8 can't start up without the source of the natives, but it can
   // start up (slower) without the snapshot.
   UMA_HISTOGRAM_ENUMERATION("V8.Initializer.LoadV8Snapshot.Result", result,
                             V8_LOAD_MAX_VALUE);
 }
 
 void V8Initializer::LoadV8Natives() {
   if (g_mapped_natives)
     return;
 
   OpenFileIfNecessary(kNativesFileName);
-  LoadV8FileResult result = MapOpenedFile(GetOpenedFile(kNativesFileName),
+  LoadV8FileResult result = MapVerify(GetOpenedFile(kNativesFileName),
+#if defined(V8_VERIFY_EXTERNAL_STARTUP_DATA)
+                                      g_natives_fingerprint,
+#endif
                                       &g_mapped_natives);
   if (result != V8_LOAD_SUCCESS) {
     LOG(FATAL) << "Couldn't mmap v8 natives data file, status code is "
                << static_cast<int>(result);
   }
 }
 
 // static
 void V8Initializer::LoadV8SnapshotFromFD(base::PlatformFile snapshot_pf,
                                          int64_t snapshot_offset,
                                          int64_t snapshot_size) {
   if (g_mapped_snapshot)
     return;
 
   if (snapshot_pf == base::kInvalidPlatformFile)
     return;
 
   base::MemoryMappedFile::Region snapshot_region =
       base::MemoryMappedFile::Region::kWholeFile;
   if (snapshot_size != 0 || snapshot_offset != 0) {
     snapshot_region.offset = snapshot_offset;
     snapshot_region.size = snapshot_size;
   }
 
   LoadV8FileResult result = V8_LOAD_SUCCESS;
   if (!MapV8File(snapshot_pf, snapshot_region, &g_mapped_snapshot))
     result = V8_LOAD_FAILED_MAP;
+#if defined(V8_VERIFY_EXTERNAL_STARTUP_DATA)
+  if (!VerifyV8StartupFile(&g_mapped_snapshot, g_snapshot_fingerprint))
+    result = V8_LOAD_FAILED_VERIFY;
+#endif  // V8_VERIFY_EXTERNAL_STARTUP_DATA
   if (result == V8_LOAD_SUCCESS) {
     g_opened_files.Get()[kSnapshotFileName] =
         std::make_pair(snapshot_pf, snapshot_region);
   }
   UMA_HISTOGRAM_ENUMERATION("V8.Initializer.LoadV8Snapshot.Result", result,
                             V8_LOAD_MAX_VALUE);
 }
 
 // static
 void V8Initializer::LoadV8NativesFromFD(base::PlatformFile natives_pf,
                                         int64_t natives_offset,
                                         int64_t natives_size) {
   if (g_mapped_natives)
     return;
 
   CHECK_NE(natives_pf, base::kInvalidPlatformFile);
 
   base::MemoryMappedFile::Region natives_region =
       base::MemoryMappedFile::Region::kWholeFile;
   if (natives_size != 0 || natives_offset != 0) {
     natives_region.offset = natives_offset;
     natives_region.size = natives_size;
   }
 
   if (!MapV8File(natives_pf, natives_region, &g_mapped_natives)) {
     LOG(FATAL) << "Couldn't mmap v8 natives data file";
   }
+#if defined(V8_VERIFY_EXTERNAL_STARTUP_DATA)
+  if (!VerifyV8StartupFile(&g_mapped_natives, g_natives_fingerprint)) {
+    LOG(FATAL) << "Couldn't verify contents of v8 natives data file";
+  }
+#endif  // V8_VERIFY_EXTERNAL_STARTUP_DATA
   g_opened_files.Get()[kNativesFileName] =
       std::make_pair(natives_pf, natives_region);
 }
 
 // static
 base::PlatformFile V8Initializer::GetOpenNativesFileForChildProcesses(
     base::MemoryMappedFile::Region* region_out) {
   const OpenedFileMap::mapped_type& opened =
       OpenFileIfNecessary(kNativesFileName);
   *region_out = opened.second;
@@ skipping 114 matching lines @@
     *snapshot_data_out =
         reinterpret_cast<const char*>(g_mapped_snapshot->data());
     *snapshot_size_out = static_cast<int>(g_mapped_snapshot->length());
   } else {
     *snapshot_data_out = NULL;
     *snapshot_size_out = 0;
   }
 }
 
 }  // namespace gin