Sanitize mini- and microdumps for webview

components/crash/content/app/breakpad_linux.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.
 
 // For linux_syscall_support.h. This makes it safe to call embedded system
 // calls when in seccomp mode.
 
 #include "components/crash/content/app/breakpad_linux.h"
 
 #include <fcntl.h>
@@ skipping 95 matching lines @@
 uint32_t g_dumps_suppressed = 0;
 char* g_process_type = nullptr;
 ExceptionHandler* g_microdump = nullptr;
 int g_signal_code_pipe_fd = -1;
 
 class MicrodumpInfo {
  public:
   MicrodumpInfo()
       : microdump_build_fingerprint_(nullptr),
         microdump_product_info_(nullptr),
-        microdump_gpu_fingerprint_(nullptr) {}
+        microdump_gpu_fingerprint_(nullptr),
+        microdump_process_type_(nullptr),
+        skip_dump_if_principal_mapping_not_referenced_(false),
+        address_within_principal_mapping_(0ul),
+        should_sanitize_dumps_(false) {}
 
   // The order in which SetGpuFingerprint and Initialize are called
   // may be dependent on the timing of the availability of GPU
   // information. For this reason, they can be called in either order,
   // resulting in the same effect.
   //
   // The following restrictions apply, however:
   // * Both methods must be called from the same thread.
   // * Both methods must be called at most once.
   //
   // Microdumps will only be generated if Initialize is called. If
   // SetGpuFingerprint has not been called called at the point at
   // which a microdump is generated, then the GPU fingerprint will be
   // UNKNOWN.
   void SetGpuFingerprint(const std::string& gpu_fingerprint);
+  void SetSkipDumpIfPrincipalMappingNotReferenced(
+      uintptr_t address_within_principal_mapping);
+  void SetShouldSanitizeDumps(bool should_sanitize_dumps);
+  void UpdateMinidumpDescriptor(MinidumpDescriptor* minidump_descriptor);
+  void UpdateExceptionHandlers();
   void Initialize(const std::string& process_type,
                   const char* product_name,
                   const char* product_version,
                   const char* android_build_fp);
 
  private:
   base::ThreadChecker thread_checker_;
   const char* microdump_build_fingerprint_;
   const char* microdump_product_info_;
   const char* microdump_gpu_fingerprint_;
   const char* microdump_process_type_;
+  bool skip_dump_if_principal_mapping_not_referenced_;
+  uintptr_t address_within_principal_mapping_;
+  bool should_sanitize_dumps_;
 };
 
 base::LazyInstance<MicrodumpInfo> g_microdump_info =
     LAZY_INSTANCE_INITIALIZER;
 
 #endif
 
 CrashKeyStorage* g_crash_keys = nullptr;
 
 // Writes the value |v| as 16 hex characters to the memory pointed at by
@@ skipping 570 matching lines @@
                      void* context,
                      bool succeeded) {
   return CrashDone(minidump, true, true, succeeded);
 }
 #endif
 
 void DumpProcess() {
 #if defined(OS_ANDROID)
   // Don't use g_breakpad and g_microdump directly here, because their
   // output might currently be suppressed.
-  if (g_breakpad) {
+
+  // If a breakpad handler is installed, but its target is a file
+  // descriptor, we can't generate a dump because we can't risk
+  // writing multiple minidumps to the FD, so it can only be used for
+  // dumps that are associated with a crash.
+  if (g_breakpad && !g_breakpad->minidump_descriptor().IsFD()) {
     ExceptionHandler(g_breakpad->minidump_descriptor(),
                      nullptr,
                      CrashDoneNoUpload,
                      nullptr,
                      false, -1).WriteMinidump();
   }
   // If microdumps are enabled write also a microdump on the system log.
   if (g_microdump) {
     ExceptionHandler(g_microdump->minidump_descriptor(),
                      nullptr,
@@ skipping 37 matching lines @@
   DCHECK(!g_breakpad);
   MinidumpDescriptor minidump_descriptor(dumps_path.value());
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kFullMemoryCrashReport)) {
     minidump_descriptor.set_size_limit(-1);  // unlimited.
   } else {
     minidump_descriptor.set_size_limit(kMaxMinidumpFileSize);
   }
 #if defined(OS_ANDROID)
   unattended = true;  // Android never uploads directly.
+  g_microdump_info.Get().UpdateMinidumpDescriptor(&minidump_descriptor);
 #endif
   if (unattended) {
     g_breakpad = new ExceptionHandler(
         minidump_descriptor,
 #if defined(OS_ANDROID)
         ShouldGenerateDump,
 #else
         nullptr,
 #endif
         CrashDoneNoUpload,
@@ skipping 33 matching lines @@
   return false;
 }
 
 bool CrashDoneInProcessNoUpload(
     const google_breakpad::MinidumpDescriptor& descriptor,
     void* context,
     const bool succeeded) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
   if (!succeeded) {
-    static const char msg[] = "Crash dump generation failed.\n";
-    WriteLog(msg, sizeof(msg) - 1);
+    if (ShouldGenerateDump(nullptr)) {
+      static const char msg[] = "Crash dump generation failed.\n";
+      WriteLog(msg, sizeof(msg) - 1);
+    }
     return false;
   }
 
   // Start constructing the message to send to the browser.
   BreakpadInfo info = {0};
   info.filename = nullptr;
   info.fd = descriptor.fd();
   info.process_type = g_process_type;
   info.process_type_length = my_strlen(g_process_type);
   info.distro = nullptr;
@@ skipping 27 matching lines @@
     return;
   }
   SetProcessStartTime();
   g_pid = getpid();
 
   g_is_crash_reporter_enabled = true;
   // Save the process type (it is leaked).
   const size_t process_type_len = process_type.size() + 1;
   g_process_type = new char[process_type_len];
   strncpy(g_process_type, process_type.c_str(), process_type_len);
-  new ExceptionHandler(MinidumpDescriptor(minidump_fd), ShouldGenerateDump,
-                       CrashDoneInProcessNoUpload, nullptr, true, -1);
+
+  MinidumpDescriptor descriptor(minidump_fd);
+  g_microdump_info.Get().UpdateMinidumpDescriptor(&descriptor);
+  g_breakpad =
+      new ExceptionHandler(descriptor, ShouldGenerateDump,
+                           CrashDoneInProcessNoUpload, nullptr, true, -1);
 }
 
 void MicrodumpInfo::SetGpuFingerprint(const std::string& gpu_fingerprint) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!microdump_gpu_fingerprint_);
   microdump_gpu_fingerprint_ = strdup(gpu_fingerprint.c_str());
   ANNOTATE_LEAKING_OBJECT_PTR(microdump_gpu_fingerprint_);
 
+  UpdateExceptionHandlers();
+}
+
+void MicrodumpInfo::SetSkipDumpIfPrincipalMappingNotReferenced(
+    uintptr_t address_within_principal_mapping) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  skip_dump_if_principal_mapping_not_referenced_ = true;
+  address_within_principal_mapping_ = address_within_principal_mapping;
+
+  UpdateExceptionHandlers();
+}
+
+void MicrodumpInfo::SetShouldSanitizeDumps(bool should_sanitize_dumps) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  should_sanitize_dumps_ = should_sanitize_dumps;
+
+  UpdateExceptionHandlers();
+}
+
+void MicrodumpInfo::UpdateMinidumpDescriptor(
+    MinidumpDescriptor* minidump_descriptor) {
+  google_breakpad::MicrodumpExtraInfo* microdump_extra_info =
+      minidump_descriptor->microdump_extra_info();
+
+  minidump_descriptor->set_skip_dump_if_principal_mapping_not_referenced(
+      skip_dump_if_principal_mapping_not_referenced_);
+  minidump_descriptor->set_address_within_principal_mapping(
+      address_within_principal_mapping_);
+  minidump_descriptor->set_sanitize_stacks(should_sanitize_dumps_);
+
+  microdump_extra_info->gpu_fingerprint = microdump_gpu_fingerprint_;
+  microdump_extra_info->product_info = microdump_product_info_;
+  microdump_extra_info->process_type = microdump_process_type_;
+  microdump_extra_info->build_fingerprint = microdump_build_fingerprint_;
+}
+
+void MicrodumpInfo::UpdateExceptionHandlers() {
+  if (g_breakpad) {
+    MinidumpDescriptor descriptor(g_breakpad->minidump_descriptor());
+    UpdateMinidumpDescriptor(&descriptor);
+    g_breakpad->set_minidump_descriptor(descriptor);
+  }
   if (g_microdump) {
-    MinidumpDescriptor minidump_descriptor(g_microdump->minidump_descriptor());
-    minidump_descriptor.microdump_extra_info()->gpu_fingerprint =
-        microdump_gpu_fingerprint_;
-    g_microdump->set_minidump_descriptor(minidump_descriptor);
+    MinidumpDescriptor descriptor(g_microdump->minidump_descriptor());
+    UpdateMinidumpDescriptor(&descriptor);
+    g_microdump->set_minidump_descriptor(descriptor);
   }
 }
 
 void MicrodumpInfo::Initialize(const std::string& process_type,
                                const char* product_name,
                                const char* product_version,
                                const char* android_build_fp) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!g_microdump);
   // |process_type| for webview's browser process is kBrowserProcessType or
   // kWebViewSingleProcessType. |process_type| for chrome's browser process is
   // an empty string.
   bool is_browser_process = process_type.empty() ||
                             process_type == kWebViewSingleProcessType ||
                             process_type == kBrowserProcessType;
 
   MinidumpDescriptor descriptor(MinidumpDescriptor::kMicrodumpOnConsole);
 
   if (product_name && product_version) {
     microdump_product_info_ =
         strdup((product_name + std::string(":") + product_version).c_str());
     ANNOTATE_LEAKING_OBJECT_PTR(microdump_product_info_);
-    descriptor.microdump_extra_info()->product_info = microdump_product_info_;
   }
 
   microdump_process_type_ =
       strdup(process_type.empty() ? kBrowserProcessType : process_type.c_str());
   ANNOTATE_LEAKING_OBJECT_PTR(microdump_process_type_);
-  descriptor.microdump_extra_info()->process_type = microdump_process_type_;
 
   if (android_build_fp) {
     microdump_build_fingerprint_ = strdup(android_build_fp);
     ANNOTATE_LEAKING_OBJECT_PTR(microdump_build_fingerprint_);
-    descriptor.microdump_extra_info()->build_fingerprint =
-        microdump_build_fingerprint_;
   }
 
-  if (microdump_gpu_fingerprint_) {
-    descriptor.microdump_extra_info()->gpu_fingerprint =
-        microdump_gpu_fingerprint_;
-  }
+  UpdateMinidumpDescriptor(&descriptor);
 
   g_microdump =
       new ExceptionHandler(descriptor, ShouldGenerateDump, MicrodumpCrashDone,
                            reinterpret_cast<void*>(is_browser_process),
                            true,  // Install handlers.
                            -1);   // Server file descriptor. -1 for in-process.
 
   if (process_type != kWebViewSingleProcessType &&
       process_type != kBrowserProcessType &&
       !process_type.empty()) {
@@ skipping 1037 matching lines @@
     minidump_descriptor.set_size_limit(-1);
     ExceptionHandler(minidump_descriptor, nullptr, MinidumpGenerated, nullptr,
                      false, -1)
         .WriteMinidump();
   }
 }
 
 void SuppressDumpGeneration() {
   g_dumps_suppressed = G_DUMPS_SUPPRESSED_MAGIC;
 }
+
+void SetSkipDumpIfPrincipalMappingNotReferenced(
+    uintptr_t address_within_principal_mapping) {
+  g_microdump_info.Get().SetSkipDumpIfPrincipalMappingNotReferenced(
+      address_within_principal_mapping);
+}
+
+void SetShouldSanitizeDumps(bool should_sanitize_dumps) {
+  g_microdump_info.Get().SetShouldSanitizeDumps(should_sanitize_dumps);
+}
 #endif  // OS_ANDROID
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }
 
 }  // namespace breakpad