Disallow packing or loading unpacked manifest v1 extensions.

chrome/browser/extensions/extension_creator.cc

 // Copyright (c) 2012 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/extensions/extension_creator.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 66 matching lines @@
     error_message_ = l10n_util::GetStringUTF8(IDS_EXTENSION_CRX_EXISTS);
     error_type_ = kCRXExists;
 
     return false;
   }
 
   return true;
 }
 
 bool ExtensionCreator::ValidateManifest(const FilePath& extension_dir,
-                                        crypto::RSAPrivateKey* key_pair) {
+                                        crypto::RSAPrivateKey* key_pair,
+                                        int run_flags) {
   std::vector<uint8> public_key_bytes;
   if (!key_pair->ExportPublicKey(&public_key_bytes)) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PUBLIC_KEY_FAILED_TO_EXPORT);
     return false;
   }
 
   std::string public_key;
   public_key.insert(public_key.begin(),
                     public_key_bytes.begin(), public_key_bytes.end());
 
   std::string extension_id;
   if (!Extension::GenerateId(public_key, &extension_id))
     return false;
 
   // Load the extension once. We don't really need it, but this does a lot of
   // useful validation of the structure.
+  int create_flags =
+      Extension::FOLLOW_SYMLINKS_ANYWHERE | Extension::ERROR_ON_PRIVATE_KEY;
+  if (run_flags & kRequireModernManifestVersion)
+    create_flags |= Extension::REQUIRE_MODERN_MANIFEST_VERSION;
+
   scoped_refptr<Extension> extension(
       extension_file_util::LoadExtension(
           extension_dir,
           extension_id,
           Extension::INTERNAL,
-          Extension::FOLLOW_SYMLINKS_ANYWHERE | Extension::ERROR_ON_PRIVATE_KEY,
+          create_flags,
           &error_message_));
   return !!extension.get();
 }
 
 crypto::RSAPrivateKey* ExtensionCreator::ReadInputKey(const FilePath&
     private_key_path) {
   if (!file_util::PathExists(private_key_path)) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_NO_EXISTS);
     return NULL;
@@ skipping 169 matching lines @@
   // Initialize Key Pair
   scoped_ptr<crypto::RSAPrivateKey> key_pair;
   if (!private_key_path.value().empty())
     key_pair.reset(ReadInputKey(private_key_path));
   else
     key_pair.reset(GenerateKey(output_private_key_path));
   if (!key_pair.get())
     return false;
 
   // Perform some extra validation by loading the extension.
-  if (!ValidateManifest(extension_dir, key_pair.get()))
+  // TODO(aa): Can this go before creating the key pair? This would mean not
+  // passing ID into LoadExtension which seems OK.
+  if (!ValidateManifest(extension_dir, key_pair.get(), run_flags))
     return false;
 
   ScopedTempDir temp_dir;
   if (!temp_dir.CreateUniqueTempDir())
     return false;
 
   // Zip up the extension.
   FilePath zip_path;
   std::vector<uint8> signature;
   bool result = false;
   if (CreateZip(extension_dir, temp_dir.path(), &zip_path) &&
       SignZip(zip_path, key_pair.get(), &signature) &&
       WriteCRX(zip_path, key_pair.get(), signature, crx_path)) {
     result = true;
   }
 
   file_util::Delete(zip_path, false);
   return result;
 }
 
 }  // namespace extensions