1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// Copyright 2014 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 COMPONENTS_UPDATE_CLIENT_COMPONENT_UNPACKER_H_
#define COMPONENTS_UPDATE_CLIENT_COMPONENT_UNPACKER_H_
#include <stdint.h>
#include <memory>
#include <string>
#include <vector>
#include "base/callback.h"
#include "base/files/file_path.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "components/update_client/update_client_errors.h"
namespace crx_file {
enum class VerifierFormat;
}
namespace update_client {
class CrxInstaller;
class ComponentPatcher;
class Patcher;
class Unzipper;
// In charge of unpacking the component CRX package and verifying that it is
// well formed and the cryptographic signature is correct.
//
// This class should be used only by the component updater. It is inspired by
// and overlaps with code in the extension's SandboxedUnpacker.
// The main differences are:
// - The public key hash is full SHA256.
// - Does not use a sandboxed unpacker. A valid component is fully trusted.
// - The manifest can have different attributes and resources are not
// transcoded.
//
// If the CRX is a delta CRX, the flow is:
// [ComponentUpdater] [ComponentPatcher]
// Unpack
// \_ Verify
// \_ Unzip
// \_ BeginPatching ---> DifferentialUpdatePatch
// ...
// EndPatching <------------ ...
// \_ EndUnpacking
//
// For a full CRX, the flow is:
// [ComponentUpdater]
// Unpack
// \_ Verify
// \_ Unzip
// \_ BeginPatching
// |
// V
// EndPatching
// \_ EndUnpacking
//
// In both cases, if there is an error at any point, the remaining steps will
// be skipped and EndUnpacking will be called.
class ComponentUnpacker : public base::RefCountedThreadSafe<ComponentUnpacker> {
public:
// Contains the result of the unpacking.
struct Result {
Result();
// Unpack error: 0 indicates success.
UnpackerError error = UnpackerError::kNone;
// Additional error information, such as errno or last error.
int extended_error = 0;
// Path of the unpacked files if the unpacking was successful.
base::FilePath unpack_path;
// The extracted public key of the package if the unpacking was successful.
std::string public_key;
};
using Callback = base::OnceCallback<void(const Result& result)>;
// Constructs an unpacker for a specific component unpacking operation.
// |pk_hash| is the expected public developer key's SHA256 hash. If empty,
// the unpacker accepts any developer key. |path| is the current location
// of the CRX.
ComponentUnpacker(const std::vector<uint8_t>& pk_hash,
const base::FilePath& path,
scoped_refptr<CrxInstaller> installer,
std::unique_ptr<Unzipper> unzipper,
scoped_refptr<Patcher> patcher,
crx_file::VerifierFormat crx_format);
// Begins the actual unpacking of the files. May invoke a patcher and the
// component installer if the package is a differential update.
// Calls |callback| with the result.
void Unpack(Callback callback);
private:
friend class base::RefCountedThreadSafe<ComponentUnpacker>;
virtual ~ComponentUnpacker();
// The first step of unpacking is to verify the file. Returns false if an
// error is encountered, the file is malformed, or the file is incorrectly
// signed.
bool Verify();
// The second step of unpacking is to unzip. Returns false if an early error
// is encountered.
bool BeginUnzipping();
void EndUnzipping(bool error);
// The third step is to optionally patch files - this is a no-op for full
// (non-differential) updates. This step is asynchronous. Returns false if an
// error is encountered.
bool BeginPatching();
void EndPatching(UnpackerError error, int extended_error);
// The final step is to do clean-up for things that can't be tidied as we go.
// If there is an error at any step, the remaining steps are skipped and
// EndUnpacking is called. EndUnpacking is responsible for calling the
// callback provided in Unpack().
void EndUnpacking();
std::vector<uint8_t> pk_hash_;
base::FilePath path_;
base::FilePath unpack_path_;
base::FilePath unpack_diff_path_;
bool is_delta_;
scoped_refptr<ComponentPatcher> patcher_;
scoped_refptr<CrxInstaller> installer_;
Callback callback_;
std::unique_ptr<Unzipper> unzipper_;
scoped_refptr<Patcher> patcher_tool_;
crx_file::VerifierFormat crx_format_;
UnpackerError error_;
int extended_error_;
std::string public_key_;
DISALLOW_COPY_AND_ASSIGN(ComponentUnpacker);
};
} // namespace update_client
#endif // COMPONENTS_UPDATE_CLIENT_COMPONENT_UNPACKER_H_
|
