Add registered shell extensions to enumerated module list on about:conflicts....

chrome/browser/enumerate_modules_model_win.cc

 // Copyright (c) 2010 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 "chrome/browser/enumerate_modules_model_win.h"
 
 #include <Tlhelp32.h>
 #include <wintrust.h>
 
 #include "app/l10n_util.h"
 #include "app/win_util.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/file_path.h"
 #include "base/file_version_info_win.h"
 #include "base/scoped_handle.h"
 #include "base/sha2.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
+#include "base/win/registry.h"
 #include "chrome/browser/net/service_providers_win.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "grit/generated_resources.h"
 
 // The period of time (in milliseconds) to wait until checking to see if any
 // incompatible modules exist.
 static const int kModuleCheckDelayMs = 60 * 1000;
 
+// The path to the Shell Extension key in the Windows registry.
+static const wchar_t kRegPath[] =
+    L"Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved";
+
 // A sort method that sorts by ModuleType ordinal (loaded module at the top),
 // then by full name (including path).
 static bool ModuleSort(const ModuleEnumerator::Module& a,
                        const ModuleEnumerator::Module& b) {
   if (a.type != b.type)
     return a.type < b.type;
   if (a.location == b.location)
     return a.name < b.name;
 
   return a.location < b.location;
@@ skipping 176 matching lines @@
       BrowserThread::FILE, FROM_HERE,
           NewRunnableMethod(this, &ModuleEnumerator::ScanOnFileThread));
 }
 
 void ModuleEnumerator::ScanOnFileThread() {
   enumerated_modules_->clear();
 
   // Make sure the path mapping vector is setup so we can collapse paths.
   PreparePathMappings();
 
+  EnumerateLoadedModules();
+  EnumerateShellExtensions();
+  EnumerateWinsockModule();
+
+  MatchAgainstBlacklist();
+
+  std::sort(enumerated_modules_->begin(),
+            enumerated_modules_->end(), ModuleSort);
+
+  // Send a reply back on the UI thread.
+  BrowserThread::PostTask(
+      callback_thread_id_, FROM_HERE,
+      NewRunnableMethod(this, &ModuleEnumerator::ReportBack));
+}
+
+void ModuleEnumerator::EnumerateLoadedModules() {
   // Get all modules in the current process.
   ScopedHandle snap(::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,
                     ::GetCurrentProcessId()));
   if (!snap.Get())
     return;
 
   // Walk the module list.
   MODULEENTRY32 module = { sizeof(module) };
   if (!::Module32First(snap.Get(), &module))
     return;
 
   do {
     // It would be weird to present chrome.exe as a loaded module.
     if (_wcsicmp(chrome::kBrowserProcessExecutableName, module.szModule) == 0)
       continue;
 
     Module entry;
     entry.type = LOADED_MODULE;
-    entry.status = NOT_MATCHED;
-    entry.normalized = false;
     entry.location = module.szExePath;
-    entry.digital_signer =
-        GetSubjectNameFromDigitalSignature(FilePath(entry.location));
-    entry.recommended_action = NONE;
-    scoped_ptr<FileVersionInfo> version_info(
-        FileVersionInfo::CreateFileVersionInfo(FilePath(entry.location)));
-    if (version_info.get()) {
-      FileVersionInfoWin* version_info_win =
-          static_cast<FileVersionInfoWin*>(version_info.get());
-
-      VS_FIXEDFILEINFO* fixed_file_info = version_info_win->fixed_file_info();
-      if (fixed_file_info) {
-        entry.description = version_info_win->file_description();
-        entry.version = version_info_win->file_version();
-        entry.product_name = version_info_win->product_name();
-      }
-    }
+    PopulateModuleInformation(&entry);
 
     NormalizeModule(&entry);
     CollapsePath(&entry);
     enumerated_modules_->push_back(entry);
   } while (::Module32Next(snap.Get(), &module));
+}
 
+void ModuleEnumerator::EnumerateShellExtensions() {
+  base::win::RegistryValueIterator registration(HKEY_LOCAL_MACHINE, kRegPath);

[huanr, 2010/11/18 22:01:13]

Do you need to enumerate keys under HKCU?

+  while (registration.Valid()) {
+    std::wstring key(std::wstring(L"CLSID\\") + registration.Name() +
+        L"\\InProcServer32");
+    base::win::RegKey clsid;
+    if (!clsid.Open(HKEY_CLASSES_ROOT, key.c_str(), KEY_READ)) {
+      ++registration;
+      continue;
+    }
+    string16 dll;
+    if (!clsid.ReadValue(L"", &dll)) {
+      ++registration;
+      continue;
+    }
+    clsid.Close();
+
+    Module entry;
+    entry.type = SHELL_EXTENSION;
+    entry.location = dll;
+    PopulateModuleInformation(&entry);
+
+    NormalizeModule(&entry);
+    CollapsePath(&entry);
+    enumerated_modules_->push_back(entry);
+
+    ++registration;
+  }
+}
+
+void ModuleEnumerator::EnumerateWinsockModule() {
   // Add to this list the Winsock LSP DLLs.
   WinsockLayeredServiceProviderList layered_providers;
   GetWinsockLayeredServiceProviders(&layered_providers);
   for (size_t i = 0; i < layered_providers.size(); ++i) {
     Module entry;
     entry.type = WINSOCK_MODULE_REGISTRATION;
     entry.status = NOT_MATCHED;
     entry.normalized = false;
     entry.location = layered_providers[i].path;
     entry.description = layered_providers[i].name;
     entry.recommended_action = NONE;
 
     wchar_t expanded[MAX_PATH];
     DWORD size = ExpandEnvironmentStrings(
         entry.location.c_str(), expanded, MAX_PATH);
     if (size != 0 && size <= MAX_PATH) {
       entry.digital_signer =
           GetSubjectNameFromDigitalSignature(FilePath(expanded));
     }
     entry.version = base::IntToString16(layered_providers[i].version);
 
     // Paths have already been collapsed.
     NormalizeModule(&entry);
     enumerated_modules_->push_back(entry);
   }
+}
 
-  MatchAgainstBlacklist();
+void ModuleEnumerator::PopulateModuleInformation(Module* module) {
+  module->status = NOT_MATCHED;
+  module->normalized = false;
+  module->digital_signer =
+      GetSubjectNameFromDigitalSignature(FilePath(module->location));
+  module->recommended_action = NONE;
+  scoped_ptr<FileVersionInfo> version_info(
+      FileVersionInfo::CreateFileVersionInfo(FilePath(module->location)));
+  if (version_info.get()) {
+    FileVersionInfoWin* version_info_win =
+        static_cast<FileVersionInfoWin*>(version_info.get());
 
-  std::sort(enumerated_modules_->begin(),
-            enumerated_modules_->end(), ModuleSort);
-
-  // Send a reply back on the UI thread.
-  BrowserThread::PostTask(
-      callback_thread_id_, FROM_HERE,
-      NewRunnableMethod(this, &ModuleEnumerator::ReportBack));
+    VS_FIXEDFILEINFO* fixed_file_info = version_info_win->fixed_file_info();
+    if (fixed_file_info) {
+      module->description = version_info_win->file_description();
+      module->version = version_info_win->file_version();
+      module->product_name = version_info_win->product_name();
+    }
+  }
 }
 
 void ModuleEnumerator::PreparePathMappings() {
   path_mapping_.clear();
 
   scoped_ptr<base::Environment> environment(base::Environment::Create());
   std::vector<string16> env_vars;
   env_vars.push_back(L"LOCALAPPDATA");
   env_vars.push_back(L"ProgramFiles");
   env_vars.push_back(L"USERPROFILE");
@@ skipping 174 matching lines @@
     return NULL;
   }
 
   ListValue* list = new ListValue();
 
   for (ModuleEnumerator::ModulesVector::const_iterator module =
            enumerated_modules_.begin();
        module != enumerated_modules_.end(); ++module) {
     DictionaryValue* data = new DictionaryValue();
     data->SetInteger("type", module->type);
-    data->SetString("type_description",
-        (module->type == ModuleEnumerator::WINSOCK_MODULE_REGISTRATION) ?
-        ASCIIToWide("Winsock") : ASCIIToWide(""));
+    switch (module->type) {
+      case ModuleEnumerator::SHELL_EXTENSION:
+        data->SetString("type_description", ASCIIToWide("Shell Extension"));
+        break;
+      case ModuleEnumerator::WINSOCK_MODULE_REGISTRATION:
+        data->SetString("type_description", ASCIIToWide("Winsock"));
+        break;
+      default:
+        data->SetString("type_description", ASCIIToWide(""));
+        break;
+    }
     data->SetInteger("status", module->status);
     data->SetString("location", module->location);
     data->SetString("name", module->name);
     data->SetString("product_name", module->product_name);
     data->SetString("description", module->description);
     data->SetString("version", module->version.empty() ? ASCIIToWide("") :
         l10n_util::GetStringF(IDS_CONFLICTS_CHECK_VERSION_STRING,
                    module->version));
     data->SetString("digital_signer", module->digital_signer);
 
@@ skipping 96 matching lines @@
   GenerateHash(WideToUTF8(module.name), &filename);
   GenerateHash(WideToUTF8(module.location), &location);
   GenerateHash(WideToUTF8(module.description), &description);
   GenerateHash(WideToUTF8(module.digital_signer), &signer);
 
   string16 url = l10n_util::GetStringF(IDS_HELP_CENTER_VIEW_CONFLICTS,
       ASCIIToWide(filename), ASCIIToWide(location),
       ASCIIToWide(description), ASCIIToWide(signer));
   return GURL(WideToUTF8(url));
 }