1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_UNPACKER_H_ 6 #define CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_UNPACKER_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "base/basictypes.h" 12 #include "base/callback.h" 13 #include "base/files/file_path.h" 14 #include "base/json/json_file_value_serializer.h" 15 #include "base/memory/ref_counted.h" 16 #include "base/memory/scoped_ptr.h" 17 #include "base/sequenced_task_runner.h" 18 19 namespace component_updater { 20 21 class ComponentInstaller; 22 class ComponentPatcher; 23 24 // Deserializes the CRX manifest. The top level must be a dictionary. 25 scoped_ptr<base::DictionaryValue> ReadManifest( 26 const base::FilePath& unpack_path); 27 28 // In charge of unpacking the component CRX package and verifying that it is 29 // well formed and the cryptographic signature is correct. If there is no 30 // error the component specific installer will be invoked to proceed with 31 // the component installation or update. 32 // 33 // This class should be used only by the component updater. It is inspired by 34 // and overlaps with code in the extension's SandboxedUnpacker. 35 // The main differences are: 36 // - The public key hash is full SHA256. 37 // - Does not use a sandboxed unpacker. A valid component is fully trusted. 38 // - The manifest can have different attributes and resources are not 39 // transcoded. 40 // 41 // If the CRX is a delta CRX, the flow is: 42 // [ComponentUpdater] [ComponentPatcher] 43 // Unpack 44 // \_ Verify 45 // \_ Unzip 46 // \_ BeginPatching ---> DifferentialUpdatePatch 47 // ... 48 // EndPatching <------------ ... 49 // \_ Install 50 // \_ Finish 51 // 52 // For a full CRX, the flow is: 53 // [ComponentUpdater] 54 // Unpack 55 // \_ Verify 56 // \_ Unzip 57 // \_ BeginPatching 58 // | 59 // V 60 // EndPatching 61 // \_ Install 62 // \_ Finish 63 // 64 // In both cases, if there is an error at any point, the remaining steps will 65 // be skipped and Finish will be called. 66 class ComponentUnpacker : public base::RefCountedThreadSafe<ComponentUnpacker> { 67 public: 68 // Possible error conditions. 69 // Add only to the bottom of this enum; the order must be kept stable. 70 enum Error { 71 kNone, 72 kInvalidParams, 73 kInvalidFile, 74 kUnzipPathError, 75 kUnzipFailed, 76 kNoManifest, 77 kBadManifest, 78 kBadExtension, 79 kInvalidId, 80 kInstallerError, 81 kIoError, 82 kDeltaVerificationFailure, 83 kDeltaBadCommands, 84 kDeltaUnsupportedCommand, 85 kDeltaOperationFailure, 86 kDeltaPatchProcessFailure, 87 kDeltaMissingExistingFile, 88 kFingerprintWriteFailed, 89 }; 90 91 typedef base::Callback<void(Error, int)> Callback; 92 93 // Constructs an unpacker for a specific component unpacking operation. 94 // |pk_hash| is the expected/ public key SHA256 hash. |path| is the current 95 // location of the CRX. 96 ComponentUnpacker(const std::vector<uint8>& pk_hash, 97 const base::FilePath& path, 98 const std::string& fingerprint, 99 ComponentInstaller* installer, 100 bool in_process, 101 scoped_refptr<base::SequencedTaskRunner> task_runner); 102 103 // Begins the actual unpacking of the files. May invoke a patcher if the 104 // package is a differential update. Calls |callback| with the result. 105 void Unpack(const Callback& callback); 106 107 private: 108 friend class base::RefCountedThreadSafe<ComponentUnpacker>; 109 110 virtual ~ComponentUnpacker(); 111 112 bool UnpackInternal(); 113 114 // The first step of unpacking is to verify the file. Returns false if an 115 // error is encountered, the file is malformed, or the file is incorrectly 116 // signed. 117 bool Verify(); 118 119 // The second step of unpacking is to unzip. Returns false if an error 120 // occurs as part of unzipping. 121 bool Unzip(); 122 123 // The third step is to optionally patch files - this is a no-op for full 124 // (non-differential) updates. This step is asynchronous. Returns false if an 125 // error is encountered. 126 bool BeginPatching(); 127 128 // When patching is complete, EndPatching is called before moving on to step 129 // four. 130 void EndPatching(Error error, int extended_error); 131 132 // The fourth step is to install the unpacked component. 133 void Install(); 134 135 // The final step is to do clean-up for things that can't be tidied as we go. 136 // If there is an error at any step, the remaining steps are skipped and 137 // and Finish is called. 138 // Finish is responsible for calling the callback provided in Start(). 139 void Finish(); 140 141 std::vector<uint8> pk_hash_; 142 base::FilePath path_; 143 base::FilePath unpack_path_; 144 base::FilePath unpack_diff_path_; 145 bool is_delta_; 146 std::string fingerprint_; 147 scoped_refptr<ComponentPatcher> patcher_; 148 ComponentInstaller* installer_; 149 Callback callback_; 150 const bool in_process_; 151 Error error_; 152 int extended_error_; 153 scoped_refptr<base::SequencedTaskRunner> task_runner_; 154 155 DISALLOW_COPY_AND_ASSIGN(ComponentUnpacker); 156 }; 157 158 } // namespace component_updater 159 160 #endif // CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_UNPACKER_H_ 161