1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "MetadataCrypt.h"
18 #include "KeyBuffer.h"
19
20 #include <string>
21
22 #include <fcntl.h>
23 #include <sys/param.h>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26
27 #include <android-base/logging.h>
28 #include <android-base/properties.h>
29 #include <android-base/strings.h>
30 #include <android-base/unique_fd.h>
31 #include <cutils/fs.h>
32 #include <fs_mgr.h>
33 #include <libdm/dm.h>
34 #include <libgsi/libgsi.h>
35
36 #include "Checkpoint.h"
37 #include "CryptoType.h"
38 #include "EncryptInplace.h"
39 #include "KeyStorage.h"
40 #include "KeyUtil.h"
41 #include "Keymaster.h"
42 #include "Utils.h"
43 #include "VoldUtil.h"
44 #include "fs/Ext4.h"
45 #include "fs/F2fs.h"
46
47 namespace android {
48 namespace vold {
49
50 using android::fs_mgr::FstabEntry;
51 using android::fs_mgr::GetEntryForMountPoint;
52 using android::vold::KeyBuffer;
53 using namespace android::dm;
54
55 // Parsed from metadata options
56 struct CryptoOptions {
57 struct CryptoType cipher = invalid_crypto_type;
58 bool use_legacy_options_format = false;
59 bool set_dun = true; // Non-legacy driver always sets DUN
60 bool use_hw_wrapped_key = false;
61 };
62
63 static const std::string kDmNameUserdata = "userdata";
64
65 // The first entry in this table is the default crypto type.
66 constexpr CryptoType supported_crypto_types[] = {aes_256_xts, adiantum};
67
68 static_assert(validateSupportedCryptoTypes(64, supported_crypto_types,
69 array_length(supported_crypto_types)),
70 "We have a CryptoType which was incompletely constructed.");
71
72 constexpr CryptoType legacy_aes_256_xts =
73 CryptoType().set_config_name("aes-256-xts").set_kernel_name("AES-256-XTS").set_keysize(64);
74
75 static_assert(isValidCryptoType(64, legacy_aes_256_xts),
76 "We have a CryptoType which was incompletely constructed.");
77
78 // Returns KeyGeneration suitable for key as described in CryptoOptions
makeGen(const CryptoOptions & options)79 const KeyGeneration makeGen(const CryptoOptions& options) {
80 return KeyGeneration{options.cipher.get_keysize(), true, options.use_hw_wrapped_key};
81 }
82
mount_via_fs_mgr(const char * mount_point,const char * blk_device)83 static bool mount_via_fs_mgr(const char* mount_point, const char* blk_device) {
84 // fs_mgr_do_mount runs fsck. Use setexeccon to run trusted
85 // partitions in the fsck domain.
86 if (setexeccon(android::vold::sFsckContext)) {
87 PLOG(ERROR) << "Failed to setexeccon";
88 return false;
89 }
90 auto mount_rc = fs_mgr_do_mount(&fstab_default, const_cast<char*>(mount_point),
91 const_cast<char*>(blk_device), nullptr,
92 android::vold::cp_needsCheckpoint(), true);
93 if (setexeccon(nullptr)) {
94 PLOG(ERROR) << "Failed to clear setexeccon";
95 return false;
96 }
97 if (mount_rc != 0) {
98 LOG(ERROR) << "fs_mgr_do_mount failed with rc " << mount_rc;
99 return false;
100 }
101 LOG(DEBUG) << "Mounted " << mount_point;
102 return true;
103 }
104
read_key(const std::string & metadata_key_dir,const KeyGeneration & gen,KeyBuffer * key)105 static bool read_key(const std::string& metadata_key_dir, const KeyGeneration& gen,
106 KeyBuffer* key) {
107 if (metadata_key_dir.empty()) {
108 LOG(ERROR) << "Failed to get metadata_key_dir";
109 return false;
110 }
111 std::string sKey;
112 auto dir = metadata_key_dir + "/key";
113 LOG(DEBUG) << "metadata_key_dir/key: " << dir;
114 if (!MkdirsSync(dir, 0700)) return false;
115 if (!pathExists(dir)) {
116 auto delete_all = android::base::GetBoolProperty(
117 "ro.crypto.metadata_init_delete_all_keys.enabled", false);
118 if (delete_all) {
119 LOG(INFO) << "Metadata key does not exist, calling deleteAllKeys";
120 Keymaster::deleteAllKeys();
121 } else {
122 LOG(DEBUG) << "Metadata key does not exist but "
123 "ro.crypto.metadata_init_delete_all_keys.enabled is false";
124 }
125 }
126 auto temp = metadata_key_dir + "/tmp";
127 return retrieveOrGenerateKey(dir, temp, kEmptyAuthentication, gen, key);
128 }
129
get_number_of_sectors(const std::string & real_blkdev,uint64_t * nr_sec)130 static bool get_number_of_sectors(const std::string& real_blkdev, uint64_t* nr_sec) {
131 if (android::vold::GetBlockDev512Sectors(real_blkdev, nr_sec) != android::OK) {
132 PLOG(ERROR) << "Unable to measure size of " << real_blkdev;
133 return false;
134 }
135 return true;
136 }
137
create_crypto_blk_dev(const std::string & dm_name,const std::string & blk_device,const KeyBuffer & key,const CryptoOptions & options,std::string * crypto_blkdev,uint64_t * nr_sec)138 static bool create_crypto_blk_dev(const std::string& dm_name, const std::string& blk_device,
139 const KeyBuffer& key, const CryptoOptions& options,
140 std::string* crypto_blkdev, uint64_t* nr_sec) {
141 if (!get_number_of_sectors(blk_device, nr_sec)) return false;
142 // TODO(paulcrowley): don't hardcode that DmTargetDefaultKey uses 4096-byte
143 // sectors
144 *nr_sec &= ~7;
145
146 KeyBuffer module_key;
147 if (options.use_hw_wrapped_key) {
148 if (!exportWrappedStorageKey(key, &module_key)) {
149 LOG(ERROR) << "Failed to get ephemeral wrapped key";
150 return false;
151 }
152 } else {
153 module_key = key;
154 }
155
156 KeyBuffer hex_key_buffer;
157 if (android::vold::StrToHex(module_key, hex_key_buffer) != android::OK) {
158 LOG(ERROR) << "Failed to turn key to hex";
159 return false;
160 }
161 std::string hex_key(hex_key_buffer.data(), hex_key_buffer.size());
162
163 auto target = std::make_unique<DmTargetDefaultKey>(0, *nr_sec, options.cipher.get_kernel_name(),
164 hex_key, blk_device, 0);
165 if (options.use_legacy_options_format) target->SetUseLegacyOptionsFormat();
166 if (options.set_dun) target->SetSetDun();
167 if (options.use_hw_wrapped_key) target->SetWrappedKeyV0();
168
169 DmTable table;
170 table.AddTarget(std::move(target));
171
172 auto& dm = DeviceMapper::Instance();
173 if (!dm.CreateDevice(dm_name, table, crypto_blkdev, std::chrono::seconds(5))) {
174 PLOG(ERROR) << "Could not create default-key device " << dm_name;
175 return false;
176 }
177 return true;
178 }
179
lookup_cipher(const std::string & cipher_name)180 static const CryptoType& lookup_cipher(const std::string& cipher_name) {
181 if (cipher_name.empty()) return supported_crypto_types[0];
182 for (size_t i = 0; i < array_length(supported_crypto_types); i++) {
183 if (cipher_name == supported_crypto_types[i].get_config_name()) {
184 return supported_crypto_types[i];
185 }
186 }
187 return invalid_crypto_type;
188 }
189
parse_options(const std::string & options_string,CryptoOptions * options)190 static bool parse_options(const std::string& options_string, CryptoOptions* options) {
191 auto parts = android::base::Split(options_string, ":");
192 if (parts.size() < 1 || parts.size() > 2) {
193 LOG(ERROR) << "Invalid metadata encryption option: " << options_string;
194 return false;
195 }
196 std::string cipher_name = parts[0];
197 options->cipher = lookup_cipher(cipher_name);
198 if (options->cipher.get_kernel_name() == nullptr) {
199 LOG(ERROR) << "No metadata cipher named " << cipher_name << " found";
200 return false;
201 }
202
203 if (parts.size() == 2) {
204 if (parts[1] == "wrappedkey_v0") {
205 options->use_hw_wrapped_key = true;
206 } else {
207 LOG(ERROR) << "Invalid metadata encryption flag: " << parts[1];
208 return false;
209 }
210 }
211 return true;
212 }
213
fscrypt_mount_metadata_encrypted(const std::string & blk_device,const std::string & mount_point,bool needs_encrypt,bool should_format,const std::string & fs_type)214 bool fscrypt_mount_metadata_encrypted(const std::string& blk_device, const std::string& mount_point,
215 bool needs_encrypt, bool should_format,
216 const std::string& fs_type) {
217 LOG(DEBUG) << "fscrypt_mount_metadata_encrypted: " << mount_point
218 << " encrypt: " << needs_encrypt << " format: " << should_format << " with "
219 << fs_type;
220 auto encrypted_state = android::base::GetProperty("ro.crypto.state", "");
221 if (encrypted_state != "" && encrypted_state != "encrypted") {
222 LOG(DEBUG) << "fscrypt_enable_crypto got unexpected starting state: " << encrypted_state;
223 return false;
224 }
225
226 auto data_rec = GetEntryForMountPoint(&fstab_default, mount_point);
227 if (!data_rec) {
228 LOG(ERROR) << "Failed to get data_rec for " << mount_point;
229 return false;
230 }
231
232 unsigned int options_format_version = android::base::GetUintProperty<unsigned int>(
233 "ro.crypto.dm_default_key.options_format.version",
234 (GetFirstApiLevel() <= __ANDROID_API_Q__ ? 1 : 2));
235
236 CryptoOptions options;
237 if (options_format_version == 1) {
238 if (!data_rec->metadata_encryption.empty()) {
239 LOG(ERROR) << "metadata_encryption options cannot be set in legacy mode";
240 return false;
241 }
242 options.cipher = legacy_aes_256_xts;
243 options.use_legacy_options_format = true;
244 options.set_dun = android::base::GetBoolProperty("ro.crypto.set_dun", false);
245 if (!options.set_dun && data_rec->fs_mgr_flags.checkpoint_blk) {
246 LOG(ERROR)
247 << "Block checkpoints and metadata encryption require ro.crypto.set_dun option";
248 return false;
249 }
250 } else if (options_format_version == 2) {
251 if (!parse_options(data_rec->metadata_encryption, &options)) return false;
252 } else {
253 LOG(ERROR) << "Unknown options_format_version: " << options_format_version;
254 return false;
255 }
256
257 auto gen = needs_encrypt ? makeGen(options) : neverGen();
258 KeyBuffer key;
259 if (!read_key(data_rec->metadata_key_dir, gen, &key)) return false;
260
261 std::string crypto_blkdev;
262 uint64_t nr_sec;
263 if (!create_crypto_blk_dev(kDmNameUserdata, blk_device, key, options, &crypto_blkdev, &nr_sec))
264 return false;
265
266 if (needs_encrypt) {
267 if (should_format) {
268 status_t error;
269
270 if (fs_type == "ext4") {
271 error = ext4::Format(crypto_blkdev, 0, mount_point);
272 } else if (fs_type == "f2fs") {
273 error = f2fs::Format(crypto_blkdev);
274 } else {
275 LOG(ERROR) << "Unknown filesystem type: " << fs_type;
276 return false;
277 }
278 LOG(DEBUG) << "Format (err=" << error << ") " << crypto_blkdev << " on " << mount_point;
279 if (error != 0) return false;
280 } else {
281 if (!encrypt_inplace(crypto_blkdev, blk_device, nr_sec, false)) return false;
282 }
283 }
284
285 LOG(DEBUG) << "Mounting metadata-encrypted filesystem:" << mount_point;
286 mount_via_fs_mgr(mount_point.c_str(), crypto_blkdev.c_str());
287
288 // Record that there's at least one fstab entry with metadata encryption
289 if (!android::base::SetProperty("ro.crypto.metadata.enabled", "true")) {
290 LOG(WARNING) << "failed to set ro.crypto.metadata.enabled"; // This isn't fatal
291 }
292 return true;
293 }
294
get_volume_options(CryptoOptions * options)295 static bool get_volume_options(CryptoOptions* options) {
296 return parse_options(android::base::GetProperty("ro.crypto.volume.metadata.encryption", ""),
297 options);
298 }
299
defaultkey_volume_keygen(KeyGeneration * gen)300 bool defaultkey_volume_keygen(KeyGeneration* gen) {
301 CryptoOptions options;
302 if (!get_volume_options(&options)) return false;
303 *gen = makeGen(options);
304 return true;
305 }
306
defaultkey_setup_ext_volume(const std::string & label,const std::string & blk_device,const KeyBuffer & key,std::string * out_crypto_blkdev)307 bool defaultkey_setup_ext_volume(const std::string& label, const std::string& blk_device,
308 const KeyBuffer& key, std::string* out_crypto_blkdev) {
309 LOG(DEBUG) << "defaultkey_setup_ext_volume: " << label << " " << blk_device;
310
311 CryptoOptions options;
312 if (!get_volume_options(&options)) return false;
313 uint64_t nr_sec;
314 return create_crypto_blk_dev(label, blk_device, key, options, out_crypto_blkdev, &nr_sec);
315 }
316
destroy_dsu_metadata_key(const std::string & dsu_slot)317 bool destroy_dsu_metadata_key(const std::string& dsu_slot) {
318 LOG(DEBUG) << "destroy_dsu_metadata_key: " << dsu_slot;
319
320 const auto dsu_metadata_key_dir = android::gsi::GetDsuMetadataKeyDir(dsu_slot);
321 if (!pathExists(dsu_metadata_key_dir)) {
322 LOG(DEBUG) << "DSU metadata_key_dir doesn't exist, nothing to remove: "
323 << dsu_metadata_key_dir;
324 return true;
325 }
326
327 // Ensure that the DSU key directory is different from the host OS'.
328 // Under normal circumstances, this should never happen, but handle it just in case.
329 if (auto data_rec = GetEntryForMountPoint(&fstab_default, "/data")) {
330 if (dsu_metadata_key_dir == data_rec->metadata_key_dir) {
331 LOG(ERROR) << "DSU metadata_key_dir is same as host OS: " << dsu_metadata_key_dir;
332 return false;
333 }
334 }
335
336 bool ok = true;
337 for (auto suffix : {"/key", "/tmp"}) {
338 const auto key_path = dsu_metadata_key_dir + suffix;
339 if (pathExists(key_path)) {
340 LOG(DEBUG) << "Destroy key: " << key_path;
341 if (!android::vold::destroyKey(key_path)) {
342 LOG(ERROR) << "Failed to destroyKey(): " << key_path;
343 ok = false;
344 }
345 }
346 }
347 if (!ok) {
348 return false;
349 }
350
351 LOG(DEBUG) << "Remove DSU metadata_key_dir: " << dsu_metadata_key_dir;
352 // DeleteDirContentsAndDir() already logged any error, so don't log repeatedly.
353 return android::vold::DeleteDirContentsAndDir(dsu_metadata_key_dir) == android::OK;
354 }
355
356 } // namespace vold
357 } // namespace android
358