Verify signed .crx extension installations

chrome/browser/extensions/extensions_service.h

 // Copyright (c) 2009 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_EXTENSIONS_EXTENSIONS_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 14 matching lines @@
 class GURL;
 class PrefService;
 class Profile;
 class ResourceDispatcherHost;
 class SkBitmap;
 class SiteInstance;
 class UserScriptMaster;
 
 typedef std::vector<Extension*> ExtensionList;
 
+
 // Manages installed and running Chromium extensions.
 class ExtensionsService
     : public base::RefCountedThreadSafe<ExtensionsService> {
  public:
+
+   // TODO(port): Move Crx package definitions to ExtentionCreator. They are
+   // currently here because ExtensionCreator is excluded on linux & mac.
+
+   // The size of the magic character sequence at the beginning of each crx
+   // file, in bytes. This should be a multiple of 4.
+   static const size_t kExtensionHeaderMagicSize = 4;
+
+   // The maximum size the crx parser will tolerate for a public key.
+   static const size_t kMaxPublicKeySize = 1 << 16;
+
+   // The maximum size the crx parser will tolerate for a signature.
+   static const size_t kMaxSignatureSize = 1 << 16;
+
+   // The magic character sequence at the beginning of each crx file.
+   static const char kExtensionHeaderMagic[];
+
+   // The current version of the crx format.
+   static const uint32 kCurrentVersion = 2;
+
+   // This header is the first data at the beginning of an extension. Its
+   // contents are purposely 32-bit aligned so that it can just be slurped into
+   // a struct without manual parsing.
+   struct ExtensionHeader {
+     char magic[kExtensionHeaderMagicSize];
+     uint32 version;
+     size_t key_size;  // The size of the public key, in bytes.
+     size_t signature_size;  // The size of the signature, in bytes.
+     // An ASN.1-encoded PublicKeyInfo structure follows.
+     // The signature follows.
+   };
+
   ExtensionsService(Profile* profile,
                     MessageLoop* frontend_loop,
                     MessageLoop* backend_loop,
                     const std::string& registry_path);
   ~ExtensionsService();
 
   // Gets the list of currently installed extensions.
   const ExtensionList* extensions() const {
     return &extensions_;
   }
@@ skipping 52 matching lines @@
 
  private:
   // For OnExtensionLoaded, OnExtensionInstalled, and
   // OnExtensionVersionReinstalled.
   friend class ExtensionsServiceBackend;
 
   // Called by the backend when extensions have been loaded.
   void OnExtensionsLoaded(ExtensionList* extensions);
 
   // Called by the backend when an extensoin hsa been installed.
-  void OnExtensionInstalled(Extension* extension, bool is_update);
+  void OnExtensionInstalled(Extension* extension,
+      Extension::InstallType install_type);
 
   // Called by the backend when an external extension has been installed.
   void OnExternalExtensionInstalled(
       const std::string& id, Extension::Location location);
 
-  // Called by the backend when an extension has been reinstalled.
-  void OnExtensionVersionReinstalled(const std::string& id);
+  // Called by the backend when an attempt was made to reinstall the same
+  // version of an existing extension.
+  void OnExtensionOverinstallAttempted(const std::string& id);
 
   // The name of the directory inside the profile where extensions are
   // installed to.
   static const char* kInstallDirectoryName;
 
   // Preferences for the owning profile.
   PrefService* prefs_;
 
   // The message loop to use with the backend.
   MessageLoop* backend_loop_;
@@ skipping 62 matching lines @@
 
   // Deletes all versions of the extension from the filesystem. Note that only
   // extensions whose location() == INTERNAL can be uninstalled. Attempting to
   // uninstall other extensions will silently fail.
   void UninstallExtension(const std::string& extension_id);
 
  private:
   class UnpackerClient;
   friend class UnpackerClient;
 
+  // Utility function to read an extension manifest and return it as a
+  // DictionaryValue. If it fails, NULL is returned and |error| contains an
+  // appropriate message.
+  DictionaryValue* ReadManifest(FilePath manifest_path, std::string* error);
+
   // Load a single extension from |extension_path|, the top directory of
   // a specific extension where its manifest file lives.
   Extension* LoadExtension(const FilePath& extension_path, bool require_id);
 
   // Load a single extension from |extension_path|, the top directory of
   // a versioned extension where its Current Version file lives.
   Extension* LoadExtensionCurrentVersion(const FilePath& extension_path);
 
   // Install a crx file at |extension_path|. If |expected_id| is not empty, it's
   // verified against the extension's manifest before installation. If
   // |from_external| is true, this extension install is from an external source,
   // ie the Windows registry, and will be marked as such. If the extension is
   // already installed, install the new version only if its version number is
   // greater than the current installed version.
   void InstallOrUpdateExtension(const FilePath& extension_path,
                                 const std::string& expected_id,
                                 bool from_external);
 
+  // Validates the signature of the extension in |extension_path|. Returns true
+  // and the public key (in |key|) if the signature validates, false otherwise.
+  bool ValidateSignature(const FilePath& extension_path, std::string* key_out);
+
   // Finish installing an extension after it has been unpacked to
   // |temp_extension_dir| by our utility process.  If |expected_id| is not
   // empty, it's verified against the extension's manifest before installation.
   // |manifest| and |images| are parsed information from the extension that
   // we want to write to disk in the browser process.
   void OnExtensionUnpacked(
       const FilePath& extension_path,
       const FilePath& temp_extension_dir,
       const std::string expected_id,
       bool from_external,
       const DictionaryValue& manifest,
       const std::vector< Tuple2<SkBitmap, FilePath> >& images);
 
   // Notify the frontend that there was an error loading an extension.
   void ReportExtensionLoadError(const FilePath& extension_path,
                                 const std::string& error);
 
   // Notify the frontend that extensions were loaded.
   void ReportExtensionsLoaded(ExtensionList* extensions);
 
   // Notify the frontend that there was an error installing an extension.
   void ReportExtensionInstallError(const FilePath& extension_path,
                                    const std::string& error);
 
-  // Notify the frontend that the extension had already been installed.
-  void ReportExtensionVersionReinstalled(const std::string& id);
+  // Notify the frontend that an attempt was made (but not carried out) to
+  // install the same version of an existing extension.
+  void ReportExtensionOverinstallAttempted(const std::string& id);
 
   // Checks a set of strings (containing id's to ignore) in order to determine
   // if the extension should be installed.
   bool ShouldSkipInstallingExtension(const std::set<std::string>& ids_to_ignore,
                                      const std::string& id);
 
   // Installs the extension if the extension is a newer version or if the
   // extension hasn't been installed before.
   void CheckVersionAndInstallExtension(const std::string& id,
                                        const std::string& extension_version,
                                        const FilePath& extension_path,
                                        bool from_external);
 
   // Read the manifest from the front of the extension file.
   // Caller takes ownership of return value.
   DictionaryValue* ReadManifest(const FilePath& extension_path);
 
   // Reads the Current Version file from |dir| into |version_string|.
   bool ReadCurrentVersion(const FilePath& dir, std::string* version_string);
 
-  // Check that the version to be installed is greater than the current
-  // installed extension.
-  bool CheckCurrentVersion(const std::string& version,
-                           const std::string& current_version,
-                           const FilePath& dest_dir);
+  // Look for an existing installation of the extension |id| & return
+  // an InstallType that would result from installing |new_version_str|.
+  Extension::InstallType CompareToInstalledVersion(const std::string& id,
+      const std::string& new_version_str, std::string* current_version_str);
+
+  // Does an existing installed extension need to be reinstalled.
+  bool NeedsReinstall(const std::string& id,
+                      const std::string& current_version);
 
   // Install the extension dir by moving it from |source| to |dest| safely.
   bool InstallDirSafely(const FilePath& source,
                         const FilePath& dest);
 
   // Update the CurrentVersion file in |dest_dir| to |version|.
   bool SetCurrentVersion(const FilePath& dest_dir,
                          std::string version);
 
   // For the extension in |version_path| with |id|, check to see if it's an
@@ skipping 30 matching lines @@
 
   // The path to look for externally registered extensions in. This is a
   // registry key on windows, but it could be a similar string for the
   // appropriate system on other platforms in the future.
   std::string registry_path_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionsServiceBackend);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_