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 <algorithm>
21 #include <string>
22 #include <thread>
23 #include <vector>
24 
25 #include <fcntl.h>
26 #include <sys/param.h>
27 #include <sys/stat.h>
28 #include <sys/types.h>
29 
30 #include <android-base/file.h>
31 #include <android-base/logging.h>
32 #include <android-base/properties.h>
33 #include <android-base/strings.h>
34 #include <android-base/unique_fd.h>
35 #include <cutils/fs.h>
36 #include <fs_mgr.h>
37 #include <libdm/dm.h>
38 
39 #include "Checkpoint.h"
40 #include "CryptoType.h"
41 #include "EncryptInplace.h"
42 #include "KeyStorage.h"
43 #include "KeyUtil.h"
44 #include "Keymaster.h"
45 #include "Utils.h"
46 #include "VoldUtil.h"
47 
48 #define TABLE_LOAD_RETRIES 10
49 
50 namespace android {
51 namespace vold {
52 
53 using android::fs_mgr::FstabEntry;
54 using android::fs_mgr::GetEntryForMountPoint;
55 using android::vold::KeyBuffer;
56 using namespace android::dm;
57 
58 // Parsed from metadata options
59 struct CryptoOptions {
60     struct CryptoType cipher = invalid_crypto_type;
61     bool use_legacy_options_format = false;
62     bool set_dun = true;  // Non-legacy driver always sets DUN
63     bool use_hw_wrapped_key = false;
64 };
65 
66 static const std::string kDmNameUserdata = "userdata";
67 
68 static const char* kFn_keymaster_key_blob = "keymaster_key_blob";
69 static const char* kFn_keymaster_key_blob_upgraded = "keymaster_key_blob_upgraded";
70 
71 // The first entry in this table is the default crypto type.
72 constexpr CryptoType supported_crypto_types[] = {aes_256_xts, adiantum};
73 
74 static_assert(validateSupportedCryptoTypes(64, supported_crypto_types,
75                                            array_length(supported_crypto_types)),
76               "We have a CryptoType which was incompletely constructed.");
77 
78 constexpr CryptoType legacy_aes_256_xts =
79         CryptoType().set_config_name("aes-256-xts").set_kernel_name("AES-256-XTS").set_keysize(64);
80 
81 static_assert(isValidCryptoType(64, legacy_aes_256_xts),
82               "We have a CryptoType which was incompletely constructed.");
83 
84 // Returns KeyGeneration suitable for key as described in CryptoOptions
makeGen(const CryptoOptions & options)85 const KeyGeneration makeGen(const CryptoOptions& options) {
86     return KeyGeneration{options.cipher.get_keysize(), true, options.use_hw_wrapped_key};
87 }
88 
mount_via_fs_mgr(const char * mount_point,const char * blk_device)89 static bool mount_via_fs_mgr(const char* mount_point, const char* blk_device) {
90     // We're about to mount data not verified by verified boot.  Tell Keymaster instances that early
91     // boot has ended.
92     ::android::vold::Keymaster::earlyBootEnded();
93 
94     // fs_mgr_do_mount runs fsck. Use setexeccon to run trusted
95     // partitions in the fsck domain.
96     if (setexeccon(android::vold::sFsckContext)) {
97         PLOG(ERROR) << "Failed to setexeccon";
98         return false;
99     }
100     auto mount_rc = fs_mgr_do_mount(&fstab_default, const_cast<char*>(mount_point),
101                                     const_cast<char*>(blk_device), nullptr,
102                                     android::vold::cp_needsCheckpoint(), true);
103     if (setexeccon(nullptr)) {
104         PLOG(ERROR) << "Failed to clear setexeccon";
105         return false;
106     }
107     if (mount_rc != 0) {
108         LOG(ERROR) << "fs_mgr_do_mount failed with rc " << mount_rc;
109         return false;
110     }
111     LOG(DEBUG) << "Mounted " << mount_point;
112     return true;
113 }
114 
115 // Note: It is possible to orphan a key if it is removed before deleting
116 // Update this once keymaster APIs change, and we have a proper commit.
commit_key(const std::string & dir)117 static void commit_key(const std::string& dir) {
118     while (!android::base::WaitForProperty("vold.checkpoint_committed", "1")) {
119         LOG(ERROR) << "Wait for boot timed out";
120     }
121     Keymaster keymaster;
122     auto keyPath = dir + "/" + kFn_keymaster_key_blob;
123     auto newKeyPath = dir + "/" + kFn_keymaster_key_blob_upgraded;
124     std::string key;
125 
126     if (!android::base::ReadFileToString(keyPath, &key)) {
127         LOG(ERROR) << "Failed to read old key: " << dir;
128         return;
129     }
130     if (rename(newKeyPath.c_str(), keyPath.c_str()) != 0) {
131         PLOG(ERROR) << "Unable to move upgraded key to location: " << keyPath;
132         return;
133     }
134     if (!keymaster.deleteKey(key)) {
135         LOG(ERROR) << "Key deletion failed during upgrade, continuing anyway: " << dir;
136     }
137     LOG(INFO) << "Old Key deleted: " << dir;
138 }
139 
read_key(const std::string & metadata_key_dir,const KeyGeneration & gen,KeyBuffer * key)140 static bool read_key(const std::string& metadata_key_dir, const KeyGeneration& gen,
141                      KeyBuffer* key) {
142     if (metadata_key_dir.empty()) {
143         LOG(ERROR) << "Failed to get metadata_key_dir";
144         return false;
145     }
146     std::string sKey;
147     auto dir = metadata_key_dir + "/key";
148     LOG(DEBUG) << "metadata_key_dir/key: " << dir;
149     if (fs_mkdirs(dir.c_str(), 0700)) {
150         PLOG(ERROR) << "Creating directories: " << dir;
151         return false;
152     }
153     auto temp = metadata_key_dir + "/tmp";
154     auto newKeyPath = dir + "/" + kFn_keymaster_key_blob_upgraded;
155     /* If we have a leftover upgraded key, delete it.
156      * We either failed an update and must return to the old key,
157      * or we rebooted before commiting the keys in a freak accident.
158      * Either way, we can re-upgrade the key if we need to.
159      */
160     Keymaster keymaster;
161     if (pathExists(newKeyPath)) {
162         if (!android::base::ReadFileToString(newKeyPath, &sKey))
163             LOG(ERROR) << "Failed to read incomplete key: " << dir;
164         else if (!keymaster.deleteKey(sKey))
165             LOG(ERROR) << "Incomplete key deletion failed, continuing anyway: " << dir;
166         else
167             unlink(newKeyPath.c_str());
168     }
169     bool needs_cp = cp_needsCheckpoint();
170     if (!retrieveOrGenerateKey(dir, temp, kEmptyAuthentication, gen, key, needs_cp)) return false;
171     if (needs_cp && pathExists(newKeyPath)) std::thread(commit_key, dir).detach();
172     return true;
173 }
174 
get_number_of_sectors(const std::string & real_blkdev,uint64_t * nr_sec)175 static bool get_number_of_sectors(const std::string& real_blkdev, uint64_t* nr_sec) {
176     if (android::vold::GetBlockDev512Sectors(real_blkdev, nr_sec) != android::OK) {
177         PLOG(ERROR) << "Unable to measure size of " << real_blkdev;
178         return false;
179     }
180     return true;
181 }
182 
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)183 static bool create_crypto_blk_dev(const std::string& dm_name, const std::string& blk_device,
184                                   const KeyBuffer& key, const CryptoOptions& options,
185                                   std::string* crypto_blkdev, uint64_t* nr_sec) {
186     if (!get_number_of_sectors(blk_device, nr_sec)) return false;
187     // TODO(paulcrowley): don't hardcode that DmTargetDefaultKey uses 4096-byte
188     // sectors
189     *nr_sec &= ~7;
190 
191     KeyBuffer module_key;
192     if (options.use_hw_wrapped_key) {
193         if (!exportWrappedStorageKey(key, &module_key)) {
194             LOG(ERROR) << "Failed to get ephemeral wrapped key";
195             return false;
196         }
197     } else {
198         module_key = key;
199     }
200 
201     KeyBuffer hex_key_buffer;
202     if (android::vold::StrToHex(module_key, hex_key_buffer) != android::OK) {
203         LOG(ERROR) << "Failed to turn key to hex";
204         return false;
205     }
206     std::string hex_key(hex_key_buffer.data(), hex_key_buffer.size());
207 
208     auto target = std::make_unique<DmTargetDefaultKey>(0, *nr_sec, options.cipher.get_kernel_name(),
209                                                        hex_key, blk_device, 0);
210     if (options.use_legacy_options_format) target->SetUseLegacyOptionsFormat();
211     if (options.set_dun) target->SetSetDun();
212     if (options.use_hw_wrapped_key) target->SetWrappedKeyV0();
213 
214     DmTable table;
215     table.AddTarget(std::move(target));
216 
217     auto& dm = DeviceMapper::Instance();
218     for (int i = 0;; i++) {
219         if (dm.CreateDevice(dm_name, table)) {
220             break;
221         }
222         if (i + 1 >= TABLE_LOAD_RETRIES) {
223             PLOG(ERROR) << "Could not create default-key device " << dm_name;
224             return false;
225         }
226         PLOG(INFO) << "Could not create default-key device, retrying";
227         usleep(500000);
228     }
229 
230     if (!dm.GetDmDevicePathByName(dm_name, crypto_blkdev)) {
231         LOG(ERROR) << "Cannot retrieve default-key device status " << dm_name;
232         return false;
233     }
234     return true;
235 }
236 
lookup_cipher(const std::string & cipher_name)237 static const CryptoType& lookup_cipher(const std::string& cipher_name) {
238     if (cipher_name.empty()) return supported_crypto_types[0];
239     for (size_t i = 0; i < array_length(supported_crypto_types); i++) {
240         if (cipher_name == supported_crypto_types[i].get_config_name()) {
241             return supported_crypto_types[i];
242         }
243     }
244     return invalid_crypto_type;
245 }
246 
parse_options(const std::string & options_string,CryptoOptions * options)247 static bool parse_options(const std::string& options_string, CryptoOptions* options) {
248     auto parts = android::base::Split(options_string, ":");
249     if (parts.size() < 1 || parts.size() > 2) {
250         LOG(ERROR) << "Invalid metadata encryption option: " << options_string;
251         return false;
252     }
253     std::string cipher_name = parts[0];
254     options->cipher = lookup_cipher(cipher_name);
255     if (options->cipher.get_kernel_name() == nullptr) {
256         LOG(ERROR) << "No metadata cipher named " << cipher_name << " found";
257         return false;
258     }
259 
260     if (parts.size() == 2) {
261         if (parts[1] == "wrappedkey_v0") {
262             options->use_hw_wrapped_key = true;
263         } else {
264             LOG(ERROR) << "Invalid metadata encryption flag: " << parts[1];
265             return false;
266         }
267     }
268     return true;
269 }
270 
fscrypt_mount_metadata_encrypted(const std::string & blk_device,const std::string & mount_point,bool needs_encrypt)271 bool fscrypt_mount_metadata_encrypted(const std::string& blk_device, const std::string& mount_point,
272                                       bool needs_encrypt) {
273     LOG(DEBUG) << "fscrypt_mount_metadata_encrypted: " << mount_point << " " << needs_encrypt;
274     auto encrypted_state = android::base::GetProperty("ro.crypto.state", "");
275     if (encrypted_state != "" && encrypted_state != "encrypted") {
276         LOG(DEBUG) << "fscrypt_enable_crypto got unexpected starting state: " << encrypted_state;
277         return false;
278     }
279 
280     auto data_rec = GetEntryForMountPoint(&fstab_default, mount_point);
281     if (!data_rec) {
282         LOG(ERROR) << "Failed to get data_rec for " << mount_point;
283         return false;
284     }
285 
286     constexpr unsigned int pre_gki_level = 29;
287     unsigned int options_format_version = android::base::GetUintProperty<unsigned int>(
288             "ro.crypto.dm_default_key.options_format.version",
289             (GetFirstApiLevel() <= pre_gki_level ? 1 : 2));
290 
291     CryptoOptions options;
292     if (options_format_version == 1) {
293         if (!data_rec->metadata_encryption.empty()) {
294             LOG(ERROR) << "metadata_encryption options cannot be set in legacy mode";
295             return false;
296         }
297         options.cipher = legacy_aes_256_xts;
298         options.use_legacy_options_format = true;
299         options.set_dun = android::base::GetBoolProperty("ro.crypto.set_dun", false);
300         if (!options.set_dun && data_rec->fs_mgr_flags.checkpoint_blk) {
301             LOG(ERROR)
302                     << "Block checkpoints and metadata encryption require ro.crypto.set_dun option";
303             return false;
304         }
305     } else if (options_format_version == 2) {
306         if (!parse_options(data_rec->metadata_encryption, &options)) return false;
307     } else {
308         LOG(ERROR) << "Unknown options_format_version: " << options_format_version;
309         return false;
310     }
311 
312     auto gen = needs_encrypt ? makeGen(options) : neverGen();
313     KeyBuffer key;
314     if (!read_key(data_rec->metadata_key_dir, gen, &key)) return false;
315 
316     std::string crypto_blkdev;
317     uint64_t nr_sec;
318     if (!create_crypto_blk_dev(kDmNameUserdata, blk_device, key, options, &crypto_blkdev, &nr_sec))
319         return false;
320 
321     // FIXME handle the corrupt case
322     if (needs_encrypt) {
323         LOG(INFO) << "Beginning inplace encryption, nr_sec: " << nr_sec;
324         off64_t size_already_done = 0;
325         auto rc = cryptfs_enable_inplace(crypto_blkdev.data(), blk_device.data(), nr_sec,
326                                          &size_already_done, nr_sec, 0, false);
327         if (rc != 0) {
328             LOG(ERROR) << "Inplace crypto failed with code: " << rc;
329             return false;
330         }
331         if (static_cast<uint64_t>(size_already_done) != nr_sec) {
332             LOG(ERROR) << "Inplace crypto only got up to sector: " << size_already_done;
333             return false;
334         }
335         LOG(INFO) << "Inplace encryption complete";
336     }
337 
338     LOG(DEBUG) << "Mounting metadata-encrypted filesystem:" << mount_point;
339     mount_via_fs_mgr(mount_point.c_str(), crypto_blkdev.c_str());
340 
341     // Record that there's at least one fstab entry with metadata encryption
342     if (!android::base::SetProperty("ro.crypto.metadata.enabled", "true")) {
343         LOG(WARNING) << "failed to set ro.crypto.metadata.enabled";  // This isn't fatal
344     }
345     return true;
346 }
347 
get_volume_options(CryptoOptions * options)348 static bool get_volume_options(CryptoOptions* options) {
349     return parse_options(android::base::GetProperty("ro.crypto.volume.metadata.encryption", ""),
350                          options);
351 }
352 
defaultkey_volume_keygen(KeyGeneration * gen)353 bool defaultkey_volume_keygen(KeyGeneration* gen) {
354     CryptoOptions options;
355     if (!get_volume_options(&options)) return false;
356     *gen = makeGen(options);
357     return true;
358 }
359 
defaultkey_setup_ext_volume(const std::string & label,const std::string & blk_device,const KeyBuffer & key,std::string * out_crypto_blkdev)360 bool defaultkey_setup_ext_volume(const std::string& label, const std::string& blk_device,
361                                  const KeyBuffer& key, std::string* out_crypto_blkdev) {
362     LOG(DEBUG) << "defaultkey_setup_ext_volume: " << label << " " << blk_device;
363 
364     CryptoOptions options;
365     if (!get_volume_options(&options)) return false;
366     uint64_t nr_sec;
367     return create_crypto_blk_dev(label, blk_device, key, options, out_crypto_blkdev, &nr_sec);
368 }
369 
370 }  // namespace vold
371 }  // namespace android
372