blob: e68e1efbcd7dc764ad7d120cadc477156c079f64 [file] [log] [blame]
Paul Crowleyd5759812016-06-02 11:04:27 -07001/*
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"
Paul Crowley14c8c072018-09-18 13:30:21 -070018#include "KeyBuffer.h"
Paul Crowleyd5759812016-06-02 11:04:27 -070019
20#include <string>
Paul Crowleyd5759812016-06-02 11:04:27 -070021
22#include <fcntl.h>
Paul Crowleyd5759812016-06-02 11:04:27 -070023#include <sys/param.h>
24#include <sys/stat.h>
25#include <sys/types.h>
26
Paul Crowleyd5759812016-06-02 11:04:27 -070027#include <android-base/logging.h>
Paul Crowley0fd26262018-01-30 09:48:19 -080028#include <android-base/properties.h>
Barani Muthukumaran312b7df2020-02-06 22:56:27 -080029#include <android-base/strings.h>
Paul Crowleye4c93da2017-06-16 09:21:18 -070030#include <android-base/unique_fd.h>
Paul Crowley0fd26262018-01-30 09:48:19 -080031#include <cutils/fs.h>
Paul Crowleyd5759812016-06-02 11:04:27 -070032#include <fs_mgr.h>
David Andersonb9224732019-05-13 13:02:54 -070033#include <libdm/dm.h>
Yo Chiang0af25a32020-10-07 14:20:00 +080034#include <libgsi/libgsi.h>
Paul Crowleyd5759812016-06-02 11:04:27 -070035
Daniel Rosenberg65f99c92018-08-28 01:58:49 -070036#include "Checkpoint.h"
Paul Crowley220567c2020-02-07 12:45:20 -080037#include "CryptoType.h"
Paul Crowleyd5759812016-06-02 11:04:27 -070038#include "EncryptInplace.h"
Steven Lavered7b3532020-02-12 12:49:40 -080039#include "FsCrypt.h"
Paul Crowleyd5759812016-06-02 11:04:27 -070040#include "KeyStorage.h"
41#include "KeyUtil.h"
Daniel Rosenberg690d6de2018-12-14 01:08:10 -080042#include "Keymaster.h"
Paul Crowleyd5759812016-06-02 11:04:27 -070043#include "Utils.h"
44#include "VoldUtil.h"
Jaegeuk Kim0c52c712020-12-15 09:00:49 -080045#include "fs/Ext4.h"
46#include "fs/F2fs.h"
Paul Crowleyd5759812016-06-02 11:04:27 -070047
Paul Crowley220567c2020-02-07 12:45:20 -080048namespace android {
49namespace vold {
50
Tom Cherry4c5bde22019-01-29 14:34:01 -080051using android::fs_mgr::FstabEntry;
52using android::fs_mgr::GetEntryForMountPoint;
Pavel Grafove2e2d302017-08-01 17:15:53 +010053using android::vold::KeyBuffer;
David Andersonb9224732019-05-13 13:02:54 -070054using namespace android::dm;
Pavel Grafove2e2d302017-08-01 17:15:53 +010055
Paul Crowley249c2fb2020-02-07 12:51:56 -080056// Parsed from metadata options
57struct CryptoOptions {
58 struct CryptoType cipher = invalid_crypto_type;
Paul Crowley4073c0b2020-03-22 08:02:06 -070059 bool use_legacy_options_format = false;
Paul Crowley249c2fb2020-02-07 12:51:56 -080060 bool set_dun = true; // Non-legacy driver always sets DUN
Barani Muthukumaran312b7df2020-02-06 22:56:27 -080061 bool use_hw_wrapped_key = false;
Paul Crowley249c2fb2020-02-07 12:51:56 -080062};
63
Paul Crowleyd5759812016-06-02 11:04:27 -070064static const std::string kDmNameUserdata = "userdata";
65
Paul Crowley249c2fb2020-02-07 12:51:56 -080066// The first entry in this table is the default crypto type.
Paul Crowley220567c2020-02-07 12:45:20 -080067constexpr CryptoType supported_crypto_types[] = {aes_256_xts, adiantum};
68
69static_assert(validateSupportedCryptoTypes(64, supported_crypto_types,
70 array_length(supported_crypto_types)),
71 "We have a CryptoType which was incompletely constructed.");
72
73constexpr CryptoType legacy_aes_256_xts =
74 CryptoType().set_config_name("aes-256-xts").set_kernel_name("AES-256-XTS").set_keysize(64);
75
Paul Crowley249c2fb2020-02-07 12:51:56 -080076static_assert(isValidCryptoType(64, legacy_aes_256_xts),
Paul Crowley220567c2020-02-07 12:45:20 -080077 "We have a CryptoType which was incompletely constructed.");
78
Paul Crowley249c2fb2020-02-07 12:51:56 -080079// Returns KeyGeneration suitable for key as described in CryptoOptions
80const KeyGeneration makeGen(const CryptoOptions& options) {
Barani Muthukumaran312b7df2020-02-06 22:56:27 -080081 return KeyGeneration{options.cipher.get_keysize(), true, options.use_hw_wrapped_key};
Paul Crowley249c2fb2020-02-07 12:51:56 -080082}
83
Paul Crowleyd5759812016-06-02 11:04:27 -070084static bool mount_via_fs_mgr(const char* mount_point, const char* blk_device) {
85 // fs_mgr_do_mount runs fsck. Use setexeccon to run trusted
86 // partitions in the fsck domain.
LongPing Wei7f3ab952019-01-30 16:03:14 +080087 if (setexeccon(android::vold::sFsckContext)) {
Paul Crowleyd5759812016-06-02 11:04:27 -070088 PLOG(ERROR) << "Failed to setexeccon";
89 return false;
90 }
Tom Cherry4c5bde22019-01-29 14:34:01 -080091 auto mount_rc = fs_mgr_do_mount(&fstab_default, const_cast<char*>(mount_point),
Daniel Rosenberg65f99c92018-08-28 01:58:49 -070092 const_cast<char*>(blk_device), nullptr,
Paul Lawrence67f90442020-06-12 08:12:48 -070093 android::vold::cp_needsCheckpoint(), true);
Paul Crowleyd5759812016-06-02 11:04:27 -070094 if (setexeccon(nullptr)) {
95 PLOG(ERROR) << "Failed to clear setexeccon";
96 return false;
97 }
98 if (mount_rc != 0) {
99 LOG(ERROR) << "fs_mgr_do_mount failed with rc " << mount_rc;
100 return false;
101 }
102 LOG(DEBUG) << "Mounted " << mount_point;
103 return true;
104}
105
Paul Crowley4eac2642020-02-12 11:04:05 -0800106static bool read_key(const std::string& metadata_key_dir, const KeyGeneration& gen,
107 KeyBuffer* key) {
Paul Crowley572c0242020-02-14 01:15:35 -0800108 if (metadata_key_dir.empty()) {
Paul Crowleyc9b92f02020-01-30 15:26:15 -0800109 LOG(ERROR) << "Failed to get metadata_key_dir";
Paul Crowleyd5759812016-06-02 11:04:27 -0700110 return false;
111 }
Daniel Rosenberg690d6de2018-12-14 01:08:10 -0800112 std::string sKey;
Paul Crowleyc9b92f02020-01-30 15:26:15 -0800113 auto dir = metadata_key_dir + "/key";
114 LOG(DEBUG) << "metadata_key_dir/key: " << dir;
Eric Biggersfec0c0e2021-02-16 15:59:17 -0800115 if (!MkdirsSync(dir, 0700)) return false;
Paul Crowley0f74bd42021-08-06 15:16:10 -0700116 if (!pathExists(dir)) {
117 auto delete_all = android::base::GetBoolProperty(
118 "ro.crypto.metadata_init_delete_all_keys.enabled", false);
119 if (delete_all) {
120 LOG(INFO) << "Metadata key does not exist, calling deleteAllKeys";
121 Keymaster::deleteAllKeys();
122 } else {
123 LOG(DEBUG) << "Metadata key does not exist but "
124 "ro.crypto.metadata_init_delete_all_keys.enabled is false";
125 }
126 }
Paul Crowleyc9b92f02020-01-30 15:26:15 -0800127 auto temp = metadata_key_dir + "/tmp";
Eric Biggersf74373b2020-11-05 19:58:26 -0800128 return retrieveOrGenerateKey(dir, temp, kEmptyAuthentication, gen, key);
Paul Crowleyd5759812016-06-02 11:04:27 -0700129}
130
Paul Crowley14c8c072018-09-18 13:30:21 -0700131static bool get_number_of_sectors(const std::string& real_blkdev, uint64_t* nr_sec) {
Oleksiy Avramchenko625dc782018-05-23 10:50:46 +0200132 if (android::vold::GetBlockDev512Sectors(real_blkdev, nr_sec) != android::OK) {
Paul Crowleyd5759812016-06-02 11:04:27 -0700133 PLOG(ERROR) << "Unable to measure size of " << real_blkdev;
134 return false;
135 }
Paul Crowleyd5759812016-06-02 11:04:27 -0700136 return true;
137}
138
Paul Crowley572c0242020-02-14 01:15:35 -0800139static bool create_crypto_blk_dev(const std::string& dm_name, const std::string& blk_device,
Paul Crowley249c2fb2020-02-07 12:51:56 -0800140 const KeyBuffer& key, const CryptoOptions& options,
Paul Crowley886e5722020-02-07 12:51:56 -0800141 std::string* crypto_blkdev, uint64_t* nr_sec) {
142 if (!get_number_of_sectors(blk_device, nr_sec)) return false;
143 // TODO(paulcrowley): don't hardcode that DmTargetDefaultKey uses 4096-byte
144 // sectors
145 *nr_sec &= ~7;
Paul Crowley84e84c52020-01-29 16:09:19 -0800146
Barani Muthukumaran312b7df2020-02-06 22:56:27 -0800147 KeyBuffer module_key;
148 if (options.use_hw_wrapped_key) {
149 if (!exportWrappedStorageKey(key, &module_key)) {
150 LOG(ERROR) << "Failed to get ephemeral wrapped key";
151 return false;
Paul Crowleyd5759812016-06-02 11:04:27 -0700152 }
153 } else {
Barani Muthukumaran312b7df2020-02-06 22:56:27 -0800154 module_key = key;
Paul Crowleyd5759812016-06-02 11:04:27 -0700155 }
David Andersonb9224732019-05-13 13:02:54 -0700156
157 KeyBuffer hex_key_buffer;
Barani Muthukumaran312b7df2020-02-06 22:56:27 -0800158 if (android::vold::StrToHex(module_key, hex_key_buffer) != android::OK) {
David Andersonb9224732019-05-13 13:02:54 -0700159 LOG(ERROR) << "Failed to turn key to hex";
Paul Crowleyd5759812016-06-02 11:04:27 -0700160 return false;
161 }
David Andersonb9224732019-05-13 13:02:54 -0700162 std::string hex_key(hex_key_buffer.data(), hex_key_buffer.size());
Paul Crowleyd5759812016-06-02 11:04:27 -0700163
Paul Crowley886e5722020-02-07 12:51:56 -0800164 auto target = std::make_unique<DmTargetDefaultKey>(0, *nr_sec, options.cipher.get_kernel_name(),
Barani Muthukumaran312b7df2020-02-06 22:56:27 -0800165 hex_key, blk_device, 0);
Paul Crowley4073c0b2020-03-22 08:02:06 -0700166 if (options.use_legacy_options_format) target->SetUseLegacyOptionsFormat();
Barani Muthukumaran312b7df2020-02-06 22:56:27 -0800167 if (options.set_dun) target->SetSetDun();
168 if (options.use_hw_wrapped_key) target->SetWrappedKeyV0();
Paul Crowleyd5759812016-06-02 11:04:27 -0700169
Paul Crowleyc9b92f02020-01-30 15:26:15 -0800170 DmTable table;
Barani Muthukumaran312b7df2020-02-06 22:56:27 -0800171 table.AddTarget(std::move(target));
Paul Crowleyc9b92f02020-01-30 15:26:15 -0800172
173 auto& dm = DeviceMapper::Instance();
Eric Biggers836b51b2020-10-15 14:39:34 -0700174 if (!dm.CreateDevice(dm_name, table, crypto_blkdev, std::chrono::seconds(5))) {
175 PLOG(ERROR) << "Could not create default-key device " << dm_name;
176 return false;
Paul Crowleyd5759812016-06-02 11:04:27 -0700177 }
Paul Crowleyd5759812016-06-02 11:04:27 -0700178 return true;
179}
180
Paul Crowley249c2fb2020-02-07 12:51:56 -0800181static const CryptoType& lookup_cipher(const std::string& cipher_name) {
182 if (cipher_name.empty()) return supported_crypto_types[0];
183 for (size_t i = 0; i < array_length(supported_crypto_types); i++) {
184 if (cipher_name == supported_crypto_types[i].get_config_name()) {
185 return supported_crypto_types[i];
Paul Crowley572c0242020-02-14 01:15:35 -0800186 }
187 }
188 return invalid_crypto_type;
189}
190
Paul Crowley249c2fb2020-02-07 12:51:56 -0800191static bool parse_options(const std::string& options_string, CryptoOptions* options) {
Barani Muthukumaran312b7df2020-02-06 22:56:27 -0800192 auto parts = android::base::Split(options_string, ":");
193 if (parts.size() < 1 || parts.size() > 2) {
194 LOG(ERROR) << "Invalid metadata encryption option: " << options_string;
Paul Crowley249c2fb2020-02-07 12:51:56 -0800195 return false;
Paul Crowley572c0242020-02-14 01:15:35 -0800196 }
Barani Muthukumaran312b7df2020-02-06 22:56:27 -0800197 std::string cipher_name = parts[0];
198 options->cipher = lookup_cipher(cipher_name);
199 if (options->cipher.get_kernel_name() == nullptr) {
200 LOG(ERROR) << "No metadata cipher named " << cipher_name << " found";
201 return false;
202 }
203
204 if (parts.size() == 2) {
205 if (parts[1] == "wrappedkey_v0") {
206 options->use_hw_wrapped_key = true;
207 } else {
208 LOG(ERROR) << "Invalid metadata encryption flag: " << parts[1];
209 return false;
210 }
211 }
Paul Crowley249c2fb2020-02-07 12:51:56 -0800212 return true;
Paul Crowley572c0242020-02-14 01:15:35 -0800213}
214
Paul Lawrencef376a012019-06-25 14:44:33 -0700215bool fscrypt_mount_metadata_encrypted(const std::string& blk_device, const std::string& mount_point,
Jaegeuk Kim0c52c712020-12-15 09:00:49 -0800216 bool needs_encrypt, bool should_format,
217 const std::string& fs_type) {
218 LOG(DEBUG) << "fscrypt_mount_metadata_encrypted: " << mount_point
219 << " encrypt: " << needs_encrypt << " format: " << should_format << " with "
220 << fs_type;
Paul Crowley0fd26262018-01-30 09:48:19 -0800221 auto encrypted_state = android::base::GetProperty("ro.crypto.state", "");
Nikita Ioffef850e6e2019-12-09 21:19:11 +0000222 if (encrypted_state != "" && encrypted_state != "encrypted") {
Eric Biggersa701c452018-10-23 13:06:55 -0700223 LOG(DEBUG) << "fscrypt_enable_crypto got unexpected starting state: " << encrypted_state;
Paul Crowleyd5759812016-06-02 11:04:27 -0700224 return false;
225 }
Tom Cherry4c5bde22019-01-29 14:34:01 -0800226
227 auto data_rec = GetEntryForMountPoint(&fstab_default, mount_point);
Paul Crowleyd5759812016-06-02 11:04:27 -0700228 if (!data_rec) {
Paul Crowleyc9b92f02020-01-30 15:26:15 -0800229 LOG(ERROR) << "Failed to get data_rec for " << mount_point;
230 return false;
231 }
Paul Crowley572c0242020-02-14 01:15:35 -0800232
Paul Crowley4073c0b2020-03-22 08:02:06 -0700233 unsigned int options_format_version = android::base::GetUintProperty<unsigned int>(
234 "ro.crypto.dm_default_key.options_format.version",
Eric Biggers72d07132020-08-10 10:55:56 -0700235 (GetFirstApiLevel() <= __ANDROID_API_Q__ ? 1 : 2));
Paul Crowley572c0242020-02-14 01:15:35 -0800236
Paul Crowley249c2fb2020-02-07 12:51:56 -0800237 CryptoOptions options;
Paul Crowley4073c0b2020-03-22 08:02:06 -0700238 if (options_format_version == 1) {
Barani Muthukumaran312b7df2020-02-06 22:56:27 -0800239 if (!data_rec->metadata_encryption.empty()) {
240 LOG(ERROR) << "metadata_encryption options cannot be set in legacy mode";
Paul Crowley249c2fb2020-02-07 12:51:56 -0800241 return false;
242 }
243 options.cipher = legacy_aes_256_xts;
Paul Crowley4073c0b2020-03-22 08:02:06 -0700244 options.use_legacy_options_format = true;
Neeraj Soni406be862020-05-04 23:49:03 +0530245 if (is_metadata_wrapped_key_supported())
246 options.use_hw_wrapped_key = true;
Paul Crowley249c2fb2020-02-07 12:51:56 -0800247 options.set_dun = android::base::GetBoolProperty("ro.crypto.set_dun", false);
248 if (!options.set_dun && data_rec->fs_mgr_flags.checkpoint_blk) {
249 LOG(ERROR)
250 << "Block checkpoints and metadata encryption require ro.crypto.set_dun option";
251 return false;
252 }
Paul Crowley4073c0b2020-03-22 08:02:06 -0700253 } else if (options_format_version == 2) {
Barani Muthukumaran312b7df2020-02-06 22:56:27 -0800254 if (!parse_options(data_rec->metadata_encryption, &options)) return false;
Paul Crowley4073c0b2020-03-22 08:02:06 -0700255 } else {
256 LOG(ERROR) << "Unknown options_format_version: " << options_format_version;
257 return false;
Paul Crowley572c0242020-02-14 01:15:35 -0800258 }
259
Paul Crowley249c2fb2020-02-07 12:51:56 -0800260 auto gen = needs_encrypt ? makeGen(options) : neverGen();
Paul Crowley0fd26262018-01-30 09:48:19 -0800261 KeyBuffer key;
Paul Crowley4eac2642020-02-12 11:04:05 -0800262 if (!read_key(data_rec->metadata_key_dir, gen, &key)) return false;
Paul Lawrence4b140d32019-08-07 15:22:57 -0700263
Paul Crowleyd5759812016-06-02 11:04:27 -0700264 std::string crypto_blkdev;
Paul Crowley886e5722020-02-07 12:51:56 -0800265 uint64_t nr_sec;
Paul Crowley7de53772020-03-02 12:57:58 -0800266 if (!create_crypto_blk_dev(kDmNameUserdata, blk_device, key, options, &crypto_blkdev, &nr_sec))
Paul Crowley572c0242020-02-14 01:15:35 -0800267 return false;
Paul Lawrencef376a012019-06-25 14:44:33 -0700268
Jaegeuk Kim0c52c712020-12-15 09:00:49 -0800269 if (needs_encrypt) {
270 if (should_format) {
271 status_t error;
272
273 if (fs_type == "ext4") {
274 error = ext4::Format(crypto_blkdev, 0, mount_point);
275 } else if (fs_type == "f2fs") {
276 error = f2fs::Format(crypto_blkdev);
277 } else {
278 LOG(ERROR) << "Unknown filesystem type: " << fs_type;
279 return false;
280 }
281 LOG(DEBUG) << "Format (err=" << error << ") " << crypto_blkdev << " on " << mount_point;
282 if (error != 0) return false;
283 } else {
284 if (!encrypt_inplace(crypto_blkdev, blk_device, nr_sec, false)) return false;
285 }
286 }
Paul Crowleyd5759812016-06-02 11:04:27 -0700287
Paul Crowley0fd26262018-01-30 09:48:19 -0800288 LOG(DEBUG) << "Mounting metadata-encrypted filesystem:" << mount_point;
Paul Crowley7de53772020-03-02 12:57:58 -0800289 mount_via_fs_mgr(mount_point.c_str(), crypto_blkdev.c_str());
Paul Crowley94abae02020-03-23 08:59:12 -0700290
291 // Record that there's at least one fstab entry with metadata encryption
292 if (!android::base::SetProperty("ro.crypto.metadata.enabled", "true")) {
293 LOG(WARNING) << "failed to set ro.crypto.metadata.enabled"; // This isn't fatal
294 }
Paul Crowleyd5759812016-06-02 11:04:27 -0700295 return true;
296}
Paul Crowley220567c2020-02-07 12:45:20 -0800297
Paul Crowley886e5722020-02-07 12:51:56 -0800298static bool get_volume_options(CryptoOptions* options) {
299 return parse_options(android::base::GetProperty("ro.crypto.volume.metadata.encryption", ""),
300 options);
301}
302
303bool defaultkey_volume_keygen(KeyGeneration* gen) {
304 CryptoOptions options;
305 if (!get_volume_options(&options)) return false;
306 *gen = makeGen(options);
307 return true;
308}
309
310bool defaultkey_setup_ext_volume(const std::string& label, const std::string& blk_device,
311 const KeyBuffer& key, std::string* out_crypto_blkdev) {
312 LOG(DEBUG) << "defaultkey_setup_ext_volume: " << label << " " << blk_device;
313
314 CryptoOptions options;
315 if (!get_volume_options(&options)) return false;
316 uint64_t nr_sec;
317 return create_crypto_blk_dev(label, blk_device, key, options, out_crypto_blkdev, &nr_sec);
318}
319
Yo Chiang0af25a32020-10-07 14:20:00 +0800320bool destroy_dsu_metadata_key(const std::string& dsu_slot) {
321 LOG(DEBUG) << "destroy_dsu_metadata_key: " << dsu_slot;
322
323 const auto dsu_metadata_key_dir = android::gsi::GetDsuMetadataKeyDir(dsu_slot);
324 if (!pathExists(dsu_metadata_key_dir)) {
325 LOG(DEBUG) << "DSU metadata_key_dir doesn't exist, nothing to remove: "
326 << dsu_metadata_key_dir;
327 return true;
328 }
329
330 // Ensure that the DSU key directory is different from the host OS'.
331 // Under normal circumstances, this should never happen, but handle it just in case.
332 if (auto data_rec = GetEntryForMountPoint(&fstab_default, "/data")) {
333 if (dsu_metadata_key_dir == data_rec->metadata_key_dir) {
334 LOG(ERROR) << "DSU metadata_key_dir is same as host OS: " << dsu_metadata_key_dir;
335 return false;
336 }
337 }
338
339 bool ok = true;
340 for (auto suffix : {"/key", "/tmp"}) {
341 const auto key_path = dsu_metadata_key_dir + suffix;
342 if (pathExists(key_path)) {
343 LOG(DEBUG) << "Destroy key: " << key_path;
344 if (!android::vold::destroyKey(key_path)) {
345 LOG(ERROR) << "Failed to destroyKey(): " << key_path;
346 ok = false;
347 }
348 }
349 }
350 if (!ok) {
351 return false;
352 }
353
354 LOG(DEBUG) << "Remove DSU metadata_key_dir: " << dsu_metadata_key_dir;
355 // DeleteDirContentsAndDir() already logged any error, so don't log repeatedly.
356 return android::vold::DeleteDirContentsAndDir(dsu_metadata_key_dir) == android::OK;
357}
358
Paul Crowley220567c2020-02-07 12:45:20 -0800359} // namespace vold
360} // namespace android