blob: abcf6dbac870b00cc0fab205da143bcbdfe139e9 [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
Paul Crowley14c8c072018-09-18 13:30:21 -070020#include <algorithm>
Paul Crowleyd5759812016-06-02 11:04:27 -070021#include <string>
22#include <thread>
23#include <vector>
24
25#include <fcntl.h>
Paul Crowleyd5759812016-06-02 11:04:27 -070026#include <sys/param.h>
27#include <sys/stat.h>
28#include <sys/types.h>
29
Daniel Rosenberg690d6de2018-12-14 01:08:10 -080030#include <android-base/file.h>
Paul Crowleyd5759812016-06-02 11:04:27 -070031#include <android-base/logging.h>
Paul Crowley0fd26262018-01-30 09:48:19 -080032#include <android-base/properties.h>
Paul Crowleye4c93da2017-06-16 09:21:18 -070033#include <android-base/unique_fd.h>
Paul Crowley0fd26262018-01-30 09:48:19 -080034#include <cutils/fs.h>
Paul Crowleyd5759812016-06-02 11:04:27 -070035#include <fs_mgr.h>
David Andersonb9224732019-05-13 13:02:54 -070036#include <libdm/dm.h>
Paul Crowleyd5759812016-06-02 11:04:27 -070037
Daniel Rosenberg65f99c92018-08-28 01:58:49 -070038#include "Checkpoint.h"
Paul Crowleyd5759812016-06-02 11:04:27 -070039#include "EncryptInplace.h"
40#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"
45
Paul Crowleyd5759812016-06-02 11:04:27 -070046#define TABLE_LOAD_RETRIES 10
Paul Crowleyd5759812016-06-02 11:04:27 -070047
Tom Cherry4c5bde22019-01-29 14:34:01 -080048using android::fs_mgr::FstabEntry;
49using android::fs_mgr::GetEntryForMountPoint;
Pavel Grafove2e2d302017-08-01 17:15:53 +010050using android::vold::KeyBuffer;
David Andersonb9224732019-05-13 13:02:54 -070051using namespace android::dm;
Pavel Grafove2e2d302017-08-01 17:15:53 +010052
Paul Crowleyd5759812016-06-02 11:04:27 -070053static const std::string kDmNameUserdata = "userdata";
54
Daniel Rosenberg690d6de2018-12-14 01:08:10 -080055static const char* kFn_keymaster_key_blob = "keymaster_key_blob";
56static const char* kFn_keymaster_key_blob_upgraded = "keymaster_key_blob_upgraded";
57
Paul Crowleyd5759812016-06-02 11:04:27 -070058static bool mount_via_fs_mgr(const char* mount_point, const char* blk_device) {
59 // fs_mgr_do_mount runs fsck. Use setexeccon to run trusted
60 // partitions in the fsck domain.
LongPing Wei7f3ab952019-01-30 16:03:14 +080061 if (setexeccon(android::vold::sFsckContext)) {
Paul Crowleyd5759812016-06-02 11:04:27 -070062 PLOG(ERROR) << "Failed to setexeccon";
63 return false;
64 }
Tom Cherry4c5bde22019-01-29 14:34:01 -080065 auto mount_rc = fs_mgr_do_mount(&fstab_default, const_cast<char*>(mount_point),
Daniel Rosenberg65f99c92018-08-28 01:58:49 -070066 const_cast<char*>(blk_device), nullptr,
67 android::vold::cp_needsCheckpoint());
Paul Crowleyd5759812016-06-02 11:04:27 -070068 if (setexeccon(nullptr)) {
69 PLOG(ERROR) << "Failed to clear setexeccon";
70 return false;
71 }
72 if (mount_rc != 0) {
73 LOG(ERROR) << "fs_mgr_do_mount failed with rc " << mount_rc;
74 return false;
75 }
76 LOG(DEBUG) << "Mounted " << mount_point;
77 return true;
78}
79
Daniel Rosenberg690d6de2018-12-14 01:08:10 -080080namespace android {
81namespace vold {
82
83// Note: It is possible to orphan a key if it is removed before deleting
84// Update this once keymaster APIs change, and we have a proper commit.
Greg Kaiser8ae16db2018-12-18 11:10:31 -080085static void commit_key(const std::string& dir) {
Daniel Rosenberg690d6de2018-12-14 01:08:10 -080086 while (!android::base::WaitForProperty("vold.checkpoint_committed", "1")) {
87 LOG(ERROR) << "Wait for boot timed out";
88 }
89 Keymaster keymaster;
90 auto keyPath = dir + "/" + kFn_keymaster_key_blob;
91 auto newKeyPath = dir + "/" + kFn_keymaster_key_blob_upgraded;
92 std::string key;
93
94 if (!android::base::ReadFileToString(keyPath, &key)) {
95 LOG(ERROR) << "Failed to read old key: " << dir;
96 return;
97 }
98 if (rename(newKeyPath.c_str(), keyPath.c_str()) != 0) {
99 PLOG(ERROR) << "Unable to move upgraded key to location: " << keyPath;
100 return;
101 }
102 if (!keymaster.deleteKey(key)) {
103 LOG(ERROR) << "Key deletion failed during upgrade, continuing anyway: " << dir;
104 }
105 LOG(INFO) << "Old Key deleted: " << dir;
106}
107
Tom Cherry4c5bde22019-01-29 14:34:01 -0800108static bool read_key(const FstabEntry& data_rec, bool create_if_absent, KeyBuffer* key) {
109 if (data_rec.key_dir.empty()) {
Paul Crowleyd5759812016-06-02 11:04:27 -0700110 LOG(ERROR) << "Failed to get key_dir";
111 return false;
112 }
Tom Cherry4c5bde22019-01-29 14:34:01 -0800113 std::string key_dir = data_rec.key_dir;
Daniel Rosenberg690d6de2018-12-14 01:08:10 -0800114 std::string sKey;
Paul Crowleyd5759812016-06-02 11:04:27 -0700115 auto dir = key_dir + "/key";
Paul Crowley98a23a12018-05-09 13:01:16 -0700116 LOG(DEBUG) << "key_dir/key: " << dir;
117 if (fs_mkdirs(dir.c_str(), 0700)) {
Paul Crowley0fd26262018-01-30 09:48:19 -0800118 PLOG(ERROR) << "Creating directories: " << dir;
Paul Crowley98a23a12018-05-09 13:01:16 -0700119 return false;
Paul Crowley0fd26262018-01-30 09:48:19 -0800120 }
Paul Crowleyd5759812016-06-02 11:04:27 -0700121 auto temp = key_dir + "/tmp";
Daniel Rosenberg690d6de2018-12-14 01:08:10 -0800122 auto newKeyPath = dir + "/" + kFn_keymaster_key_blob_upgraded;
123 /* If we have a leftover upgraded key, delete it.
124 * We either failed an update and must return to the old key,
125 * or we rebooted before commiting the keys in a freak accident.
126 * Either way, we can re-upgrade the key if we need to.
127 */
128 Keymaster keymaster;
129 if (pathExists(newKeyPath)) {
130 if (!android::base::ReadFileToString(newKeyPath, &sKey))
131 LOG(ERROR) << "Failed to read old key: " << dir;
132 else if (!keymaster.deleteKey(sKey))
133 LOG(ERROR) << "Old key deletion failed, continuing anyway: " << dir;
134 else
135 unlink(newKeyPath.c_str());
136 }
137 bool needs_cp = cp_needsCheckpoint();
138 if (!android::vold::retrieveKey(create_if_absent, dir, temp, key, needs_cp)) return false;
139 if (needs_cp && pathExists(newKeyPath)) std::thread(commit_key, dir).detach();
Paul Crowleyd5759812016-06-02 11:04:27 -0700140 return true;
141}
142
Daniel Rosenberg690d6de2018-12-14 01:08:10 -0800143} // namespace vold
144} // namespace android
145
Paul Crowley14c8c072018-09-18 13:30:21 -0700146static bool get_number_of_sectors(const std::string& real_blkdev, uint64_t* nr_sec) {
Oleksiy Avramchenko625dc782018-05-23 10:50:46 +0200147 if (android::vold::GetBlockDev512Sectors(real_blkdev, nr_sec) != android::OK) {
Paul Crowleyd5759812016-06-02 11:04:27 -0700148 PLOG(ERROR) << "Unable to measure size of " << real_blkdev;
149 return false;
150 }
Paul Crowleyd5759812016-06-02 11:04:27 -0700151 return true;
152}
153
Paul Crowleyd5759812016-06-02 11:04:27 -0700154static bool create_crypto_blk_dev(const std::string& dm_name, uint64_t nr_sec,
David Andersonb9224732019-05-13 13:02:54 -0700155 const std::string& real_blkdev, const KeyBuffer& key,
Paul Lawrence4b140d32019-08-07 15:22:57 -0700156 std::string* crypto_blkdev, bool set_dun) {
David Andersonb9224732019-05-13 13:02:54 -0700157 auto& dm = DeviceMapper::Instance();
158
159 KeyBuffer hex_key_buffer;
160 if (android::vold::StrToHex(key, hex_key_buffer) != android::OK) {
161 LOG(ERROR) << "Failed to turn key to hex";
Paul Crowleyd5759812016-06-02 11:04:27 -0700162 return false;
163 }
David Andersonb9224732019-05-13 13:02:54 -0700164 std::string hex_key(hex_key_buffer.data(), hex_key_buffer.size());
Paul Crowleyd5759812016-06-02 11:04:27 -0700165
David Andersonb9224732019-05-13 13:02:54 -0700166 DmTable table;
Paul Lawrence4b140d32019-08-07 15:22:57 -0700167 table.Emplace<DmTargetDefaultKey>(0, nr_sec, "AES-256-XTS", hex_key, real_blkdev, 0, set_dun);
Paul Crowleyd5759812016-06-02 11:04:27 -0700168
Paul Crowley14c8c072018-09-18 13:30:21 -0700169 for (int i = 0;; i++) {
David Andersonb9224732019-05-13 13:02:54 -0700170 if (dm.CreateDevice(dm_name, table)) {
Paul Crowleyd5759812016-06-02 11:04:27 -0700171 break;
172 }
Paul Crowley14c8c072018-09-18 13:30:21 -0700173 if (i + 1 >= TABLE_LOAD_RETRIES) {
David Andersonb9224732019-05-13 13:02:54 -0700174 LOG(ERROR) << "Could not create default-key device " << dm_name;
Paul Crowleyd5759812016-06-02 11:04:27 -0700175 return false;
176 }
David Andersonb9224732019-05-13 13:02:54 -0700177 PLOG(INFO) << "Could not create default-key device, retrying";
Paul Crowleyd5759812016-06-02 11:04:27 -0700178 usleep(500000);
179 }
180
David Andersonb9224732019-05-13 13:02:54 -0700181 if (!dm.GetDmDevicePathByName(dm_name, crypto_blkdev)) {
182 LOG(ERROR) << "Cannot retrieve default-key device status " << dm_name;
Paul Crowleyd5759812016-06-02 11:04:27 -0700183 return false;
184 }
185 return true;
186}
187
Paul Lawrence236e5e82019-06-25 14:44:33 -0700188bool fscrypt_mount_metadata_encrypted(const std::string& blk_device, const std::string& mount_point,
189 bool needs_encrypt) {
Eric Biggersa701c452018-10-23 13:06:55 -0700190 LOG(DEBUG) << "fscrypt_mount_metadata_encrypted: " << mount_point << " " << needs_encrypt;
Paul Crowley0fd26262018-01-30 09:48:19 -0800191 auto encrypted_state = android::base::GetProperty("ro.crypto.state", "");
192 if (encrypted_state != "") {
Eric Biggersa701c452018-10-23 13:06:55 -0700193 LOG(DEBUG) << "fscrypt_enable_crypto got unexpected starting state: " << encrypted_state;
Paul Crowleyd5759812016-06-02 11:04:27 -0700194 return false;
195 }
Tom Cherry4c5bde22019-01-29 14:34:01 -0800196
197 auto data_rec = GetEntryForMountPoint(&fstab_default, mount_point);
Paul Crowleyd5759812016-06-02 11:04:27 -0700198 if (!data_rec) {
199 LOG(ERROR) << "Failed to get data_rec";
200 return false;
201 }
Paul Crowley0fd26262018-01-30 09:48:19 -0800202 KeyBuffer key;
Tom Cherry4c5bde22019-01-29 14:34:01 -0800203 if (!read_key(*data_rec, needs_encrypt, &key)) return false;
Paul Crowleyd5759812016-06-02 11:04:27 -0700204 uint64_t nr_sec;
205 if (!get_number_of_sectors(data_rec->blk_device, &nr_sec)) return false;
Paul Lawrence4b140d32019-08-07 15:22:57 -0700206 bool set_dun = android::base::GetBoolProperty("ro.crypto.set_dun", false);
207 if (!set_dun && data_rec->fs_mgr_flags.checkpoint_blk) {
208 LOG(ERROR) << "Block checkpoints and metadata encryption require setdun option!";
209 return false;
210 }
211
Paul Crowleyd5759812016-06-02 11:04:27 -0700212 std::string crypto_blkdev;
Paul Lawrence4b140d32019-08-07 15:22:57 -0700213 if (!create_crypto_blk_dev(kDmNameUserdata, nr_sec, blk_device, key, &crypto_blkdev, set_dun))
Paul Crowleyd5759812016-06-02 11:04:27 -0700214 return false;
Paul Lawrence236e5e82019-06-25 14:44:33 -0700215
Paul Crowley0fd26262018-01-30 09:48:19 -0800216 // FIXME handle the corrupt case
217 if (needs_encrypt) {
218 LOG(INFO) << "Beginning inplace encryption, nr_sec: " << nr_sec;
219 off64_t size_already_done = 0;
Paul Lawrence236e5e82019-06-25 14:44:33 -0700220 auto rc = cryptfs_enable_inplace(crypto_blkdev.data(), blk_device.data(), nr_sec,
Tom Cherry4c5bde22019-01-29 14:34:01 -0800221 &size_already_done, nr_sec, 0, false);
Paul Crowley0fd26262018-01-30 09:48:19 -0800222 if (rc != 0) {
223 LOG(ERROR) << "Inplace crypto failed with code: " << rc;
224 return false;
225 }
226 if (static_cast<uint64_t>(size_already_done) != nr_sec) {
227 LOG(ERROR) << "Inplace crypto only got up to sector: " << size_already_done;
228 return false;
229 }
230 LOG(INFO) << "Inplace encryption complete";
Paul Crowleyd5759812016-06-02 11:04:27 -0700231 }
Paul Crowleyd5759812016-06-02 11:04:27 -0700232
Paul Crowley0fd26262018-01-30 09:48:19 -0800233 LOG(DEBUG) << "Mounting metadata-encrypted filesystem:" << mount_point;
Tom Cherry4c5bde22019-01-29 14:34:01 -0800234 mount_via_fs_mgr(data_rec->mount_point.c_str(), crypto_blkdev.c_str());
Paul Crowleyd5759812016-06-02 11:04:27 -0700235 return true;
236}