[win] Create utilities for helping to populate ModuleDatabase.

chrome/browser/conflicts/module_database_win.h

 // Copyright 2017 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.
 
 #ifndef CHROME_BROWSER_CONFLICTS_MODULE_DATABASE_WIN_H_
 #define CHROME_BROWSER_CONFLICTS_MODULE_DATABASE_WIN_H_
 
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "content/public/common/process_type.h"
 
 // A class that keeps track of all modules loaded across Chrome processes.
 // Drives the chrome://conflicts UI.
 //
 // This is effectively a singleton, but doesn't use base::Singleton. The intent
 // is for the object to be created when Chrome is single-threaded, and for it
 // be set as the process-wide singleton via SetInstance.
 class ModuleDatabase {
  public:
+  // Used as a unique identifier for a module in a ModuleSet.
+  using ModuleId = int;
+
+  // The type of certificate found for the module.
+  enum CertificateType {
+    // The module is not signed.
+    NO_CERTIFICATE,
+    // The module is signed and the certificate is in the module.
+    CERTIFICATE_IN_FILE,
+    // The module is signed and the certificate is in an external catalog.
+    CERTIFICATE_IN_CATALOG,
+  };
+
+  // Structures for maintaining information about modules.
+  struct ModuleInfoKey;
+  struct CertificateInfo;
+  struct ModuleInfoData;
+  using ModuleMap = std::map<ModuleInfoKey, ModuleInfoData>;
+  using ModuleInfo = ModuleMap::value_type;
+
+  // Used for maintaing a list of modules loaded in a process. Maps module IDs
+  // to load addresses.
+  using ModuleLoadAddresses = std::vector<std::pair<ModuleId, uintptr_t>>;
+
+  // Structures for maintaining information about running processes.
+  struct ProcessInfoKey;
+  struct ProcessInfoData;
+  using ProcessMap = std::map<ProcessInfoKey, ProcessInfoData>;
+  using ProcessInfo = ProcessMap::value_type;
+
   // A ModuleDatabase is by default bound to a provided sequenced task runner.
   // All calls must be made in the context of this task runner, unless
   // otherwise noted. For calls from other contexts this task runner is used to
   // bounce the call when appropriate.
   explicit ModuleDatabase(scoped_refptr<base::SequencedTaskRunner> task_runner);
   ~ModuleDatabase();
 
   // Retrieves the singleton global instance of the ModuleDatabase.
   static ModuleDatabase* GetInstance();
 
@@ skipping 37 matching lines @@
 
  private:
   friend class TestModuleDatabase;
   friend class ModuleDatabaseTest;
   friend class ModuleEventSinkImplTest;
 
   // Used by the FindLoadAddress* functions to indicate a load address has not
   // been found.
   static constexpr size_t kInvalidIndex = ~0u;
 
-  // Used as a unique identifier for a module in a ModuleSet.
-  using ModuleId = int;
-
-  // Structures for maintaining information about modules.
-  struct ModuleInfoKey;
-  struct ModuleInfoData;
-  using ModuleMap = std::map<ModuleInfoKey, ModuleInfoData>;
-  using ModuleInfo = ModuleMap::value_type;
-
-  // Used for maintaing a list of modules loaded in a process. Maps module IDs
-  // to load addresses.
-  using ModuleLoadAddresses = std::vector<std::pair<ModuleId, uintptr_t>>;
-
-  // Structures for maintaining information about running processes.
-  struct ProcessInfoKey;
-  struct ProcessInfoData;
-  using ProcessMap = std::map<ProcessInfoKey, ProcessInfoData>;
-  using ProcessInfo = ProcessMap::value_type;
-
   // Converts a valid |process_type| to a bit for use in a bitmask of process
   // values. Exposed in the header for testing.
   static uint32_t ProcessTypeToBit(content::ProcessType process_type);
 
   // Converts a |bit_index| (which maps to the bit 1 << bit_index) to the
   // corresponding process type. Exposed in the header for testing.
   static content::ProcessType BitIndexToProcessType(uint32_t bit_index);
 
   // Performs a linear scan to find the index of a |module_id| or |load_address|
   // in a collection of modules. Returns kInvalidIndex if the index is not
@@ skipping 77 matching lines @@
   // TimeDateStamp from the module's IMAGE_FILE_HEADER.
   uint32_t module_time_date_stamp;
 
   // The ID of this module. This is a strictly incrementing value, and is used
   // to tie a module to the list of running processes in which it is found.
   // It is not part of the key for the module, but it is immutable. This is
   // simply the index of the module in the insertion order.
   ModuleId module_id;
 };
 
+// Information about the certificate of a file.
+struct ModuleDatabase::CertificateInfo {
+  CertificateInfo();
+
+  // The type of signature encountered.
+  CertificateType type;
+
+  // Path to the file containing the certificate. Empty if |type| is
+  // NO_CERTIFICATE.
+  base::FilePath path;
+
+  // The "Subject" name of the certificate. This is the signer (ie,
+  // "Google Inc." or "Microsoft Inc.").
+  base::string16 subject;
+};
+
 // This is the mutable portion of the module information, and is the storage
 // type in a std::map.
 struct ModuleDatabase::ModuleInfoData {
   ModuleInfoData();
+  ModuleInfoData(const ModuleInfoData& others);
+  ~ModuleInfoData();
 
   // Set of all process types in which this module has been seen (may not be
   // currently present in a process of that type). This is a conversion of
   // ProcessType enumeration to a bitfield. See "ProcessTypeToBit" and
   // "BitIndexToProcessType" for details.
   uint32_t process_types;
+
+  // The following pieces of information are determined via a detailed
+  // inspection of the module. This is relatively expensive and uses blocking
+  // IO, so is performed in a background task.
+
+  // The module path, not including the basename. This is cleaned and normalized
+  // so that common paths are converted to their environment variable mappings
+  // (ie, %systemroot%). This makes i18n localized paths easily comparable.
+  base::string16 location;
+
+  // The basename of the module.
+  base::string16 basename;
+
+  // The name of the product the module belongs to.
+  base::string16 product_name;
+
+  // The module file description.
+  base::string16 description;
+
+  // The module version. This is usually in the form a.b.c.d (where a, b, c and
+  // d are integers), but may also have fewer than 4 components.
+  base::string16 version;
+
+  // The certificate info for the module.
+  CertificateInfo certificate_info;
 };
 
 // Information about a running process. This ties modules in a ModuleSet to
 // processes in which they are (or have been) loaded.
 
 // This is the constant portion of the process information, and acts as the key
 // in a std::map.
 struct ModuleDatabase::ProcessInfoKey {
   ProcessInfoKey(uint32_t process_id,
                  uint64_t creation_time,
@@ skipping 28 matching lines @@
   //
   // These are modified by the various static *LoadAddress* helper functions in
   // ModuleDatabase. The vector maintains the invariant the element with maximum
   // module ID is always last. This ensures that the usual operation of loading
   // a module is O(1).
   ModuleLoadAddresses loaded_modules;
   ModuleLoadAddresses unloaded_modules;
 };
 
 #endif  // CHROME_BROWSER_CONFLICTS_MODULE_DATABASE_WIN_H_