blob: 85ace4a1d3e6058e9739cba3d9f421fa00cd91eb [file] [log] [blame]
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -08001/*
2 * Copyright (C) 2015 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
Paul Lawrence731a7a22015-04-28 22:14:15 +000017#include "Ext4Crypt.h"
18
Paul Crowley1ef25582016-01-21 20:26:12 +000019#include "KeyStorage.h"
Paul Crowleyf71ace32016-06-02 11:01:19 -070020#include "KeyUtil.h"
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -080021#include "Utils.h"
Paul Crowleya7ca40b2017-10-06 14:29:33 -070022#include "VoldUtil.h"
23
Paul Crowleya3630362016-05-17 14:17:56 -070024#include <algorithm>
Paul Lawrence731a7a22015-04-28 22:14:15 +000025#include <map>
Paul Crowleyb1f3d242016-01-28 10:09:46 +000026#include <set>
Paul Lawrencefd7db732015-04-10 07:48:51 -070027#include <sstream>
Paul Crowleydf528a72016-03-09 09:31:37 -080028#include <string>
Paul Crowleyf71ace32016-06-02 11:01:19 -070029#include <vector>
Paul Lawrence731a7a22015-04-28 22:14:15 +000030
Paul Crowleydf528a72016-03-09 09:31:37 -080031#include <dirent.h>
32#include <errno.h>
33#include <fcntl.h>
Pavel Grafovb350ed02017-07-27 17:34:57 +010034#include <unistd.h>
Paul Crowleya3630362016-05-17 14:17:56 -070035#include <limits.h>
Jeff Sharkey7a9dd952016-01-12 16:52:16 -070036#include <selinux/android.h>
Paul Crowleydf528a72016-03-09 09:31:37 -080037#include <sys/mount.h>
38#include <sys/stat.h>
39#include <sys/types.h>
Paul Lawrence731a7a22015-04-28 22:14:15 +000040
Paul Crowley480fcd22015-08-24 14:53:28 +010041#include <private/android_filesystem_config.h>
42
Paul Crowley82b41ff2017-10-20 08:17:54 -070043#include "android/os/IVold.h"
44
Paul Lawrence731a7a22015-04-28 22:14:15 +000045#include "cryptfs.h"
46
Jeff Sharkey7a9dd952016-01-12 16:52:16 -070047#define EMULATED_USES_SELINUX 0
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -060048#define MANAGE_MISC_DIRS 0
Jeff Sharkey7a9dd952016-01-12 16:52:16 -070049
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -080050#include <cutils/fs.h>
Paul Crowleyf71ace32016-06-02 11:01:19 -070051#include <cutils/properties.h>
52
Paul Crowleyf71ace32016-06-02 11:01:19 -070053#include <ext4_utils/ext4_crypt.h>
Elliott Hughesc3bda182017-05-09 17:01:04 -070054#include <keyutils.h>
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -080055
Elliott Hughes7e128fb2015-12-04 15:50:53 -080056#include <android-base/file.h>
Elliott Hughes6bf05472015-12-04 17:55:33 -080057#include <android-base/logging.h>
Paul Crowley3aa914d2017-10-09 16:35:51 -070058#include <android-base/properties.h>
Elliott Hughes7e128fb2015-12-04 15:50:53 -080059#include <android-base/stringprintf.h>
Paul Lawrence731a7a22015-04-28 22:14:15 +000060
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -080061using android::base::StringPrintf;
Pavel Grafovb350ed02017-07-27 17:34:57 +010062using android::base::WriteStringToFile;
Paul Crowley05720802016-02-08 15:55:41 +000063using android::vold::kEmptyAuthentication;
Pavel Grafove2e2d302017-08-01 17:15:53 +010064using android::vold::KeyBuffer;
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -080065
Paul Lawrence731a7a22015-04-28 22:14:15 +000066namespace {
Andrew Scull7ec25c72016-10-31 10:28:25 +000067
Paul Crowley3aa914d2017-10-09 16:35:51 -070068struct PolicyKeyRef {
69 std::string contents_mode;
70 std::string filenames_mode;
71 std::string key_raw_ref;
72};
73
Paul Crowley4d2d5242016-04-27 10:25:12 -070074const std::string device_key_dir = std::string() + DATA_MNT_POINT + e4crypt_unencrypted_folder;
Paul Crowleydf528a72016-03-09 09:31:37 -080075const std::string device_key_path = device_key_dir + "/key";
76const std::string device_key_temp = device_key_dir + "/temp";
Paul Lawrence5a06a642016-02-03 13:39:13 -080077
Paul Crowleydf528a72016-03-09 09:31:37 -080078const std::string user_key_dir = std::string() + DATA_MNT_POINT + "/misc/vold/user_keys";
79const std::string user_key_temp = user_key_dir + "/temp";
Paul Crowley82b41ff2017-10-20 08:17:54 -070080const std::string prepare_subdirs_path = "/system/bin/vold_prepare_subdirs";
Paul Crowley285956f2016-01-20 13:12:38 +000081
Paul Crowley26a53882017-10-26 11:16:39 -070082const std::string systemwide_volume_key_dir =
83 std::string() + DATA_MNT_POINT + "/misc/vold/volume_keys";
84
Paul Crowleydf528a72016-03-09 09:31:37 -080085bool s_global_de_initialized = false;
Paul Lawrence7b6b5652016-02-02 11:14:59 -080086
Paul Crowleydf528a72016-03-09 09:31:37 -080087// Some users are ephemeral, don't try to wipe their keys from disk
88std::set<userid_t> s_ephemeral_users;
Paul Lawrenceaec34df2016-02-03 10:52:41 -080089
Paul Crowleydf528a72016-03-09 09:31:37 -080090// Map user ids to key references
91std::map<userid_t, std::string> s_de_key_raw_refs;
92std::map<userid_t, std::string> s_ce_key_raw_refs;
Paul Crowley99360d72016-10-19 14:00:24 -070093// TODO abolish this map, per b/26948053
Pavel Grafove2e2d302017-08-01 17:15:53 +010094std::map<userid_t, KeyBuffer> s_ce_keys;
Paul Lawrence731a7a22015-04-28 22:14:15 +000095
Paul Lawrence731a7a22015-04-28 22:14:15 +000096}
97
Paul Crowley38132a12016-02-09 09:50:32 +000098static bool e4crypt_is_emulated() {
99 return property_get_bool("persist.sys.emulate_fbe", false);
100}
101
Paul Crowley3b71fc52017-10-09 10:55:21 -0700102static const char* escape_empty(const std::string& value) {
103 return value.empty() ? "null" : value.c_str();
Paul Lawrence731a7a22015-04-28 22:14:15 +0000104}
105
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000106static std::string get_de_key_path(userid_t user_id) {
107 return StringPrintf("%s/de/%d", user_key_dir.c_str(), user_id);
108}
109
Paul Crowleya3630362016-05-17 14:17:56 -0700110static std::string get_ce_key_directory_path(userid_t user_id) {
111 return StringPrintf("%s/ce/%d", user_key_dir.c_str(), user_id);
112}
113
114// Returns the keys newest first
115static std::vector<std::string> get_ce_key_paths(const std::string& directory_path) {
116 auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(directory_path.c_str()), closedir);
117 if (!dirp) {
118 PLOG(ERROR) << "Unable to open ce key directory: " + directory_path;
119 return std::vector<std::string>();
120 }
121 std::vector<std::string> result;
122 for (;;) {
123 errno = 0;
124 auto const entry = readdir(dirp.get());
125 if (!entry) {
126 if (errno) {
127 PLOG(ERROR) << "Unable to read ce key directory: " + directory_path;
128 return std::vector<std::string>();
129 }
130 break;
131 }
132 if (entry->d_type != DT_DIR || entry->d_name[0] != 'c') {
133 LOG(DEBUG) << "Skipping non-key " << entry->d_name;
134 continue;
135 }
136 result.emplace_back(directory_path + "/" + entry->d_name);
137 }
138 std::sort(result.begin(), result.end());
139 std::reverse(result.begin(), result.end());
140 return result;
141}
142
143static std::string get_ce_key_current_path(const std::string& directory_path) {
144 return directory_path + "/current";
145}
146
147static bool get_ce_key_new_path(const std::string& directory_path,
148 const std::vector<std::string>& paths,
149 std::string *ce_key_path) {
150 if (paths.empty()) {
151 *ce_key_path = get_ce_key_current_path(directory_path);
152 return true;
153 }
154 for (unsigned int i = 0; i < UINT_MAX; i++) {
155 auto const candidate = StringPrintf("%s/cx%010u", directory_path.c_str(), i);
156 if (paths[0] < candidate) {
157 *ce_key_path = candidate;
158 return true;
159 }
160 }
161 return false;
162}
163
164// Discard all keys but the named one; rename it to canonical name.
165// No point in acting on errors in this; ignore them.
166static void fixate_user_ce_key(const std::string& directory_path, const std::string &to_fix,
167 const std::vector<std::string>& paths) {
168 for (auto const other_path: paths) {
169 if (other_path != to_fix) {
170 android::vold::destroyKey(other_path);
171 }
172 }
173 auto const current_path = get_ce_key_current_path(directory_path);
174 if (to_fix != current_path) {
175 LOG(DEBUG) << "Renaming " << to_fix << " to " << current_path;
176 if (rename(to_fix.c_str(), current_path.c_str()) != 0) {
177 PLOG(WARNING) << "Unable to rename " << to_fix << " to " << current_path;
178 }
179 }
180}
181
182static bool read_and_fixate_user_ce_key(userid_t user_id,
183 const android::vold::KeyAuthentication& auth,
Pavel Grafove2e2d302017-08-01 17:15:53 +0100184 KeyBuffer *ce_key) {
Paul Crowleya3630362016-05-17 14:17:56 -0700185 auto const directory_path = get_ce_key_directory_path(user_id);
186 auto const paths = get_ce_key_paths(directory_path);
187 for (auto const ce_key_path: paths) {
188 LOG(DEBUG) << "Trying user CE key " << ce_key_path;
189 if (android::vold::retrieveKey(ce_key_path, auth, ce_key)) {
190 LOG(DEBUG) << "Successfully retrieved key";
191 fixate_user_ce_key(directory_path, ce_key_path, paths);
192 return true;
193 }
194 }
195 LOG(ERROR) << "Failed to find working ce key for user " << user_id;
196 return false;
Paul Crowleyb33e8872015-05-19 12:34:09 +0100197}
198
Paul Crowleydf528a72016-03-09 09:31:37 -0800199static bool read_and_install_user_ce_key(userid_t user_id,
200 const android::vold::KeyAuthentication& auth) {
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000201 if (s_ce_key_raw_refs.count(user_id) != 0) return true;
Pavel Grafove2e2d302017-08-01 17:15:53 +0100202 KeyBuffer ce_key;
Paul Crowleya3630362016-05-17 14:17:56 -0700203 if (!read_and_fixate_user_ce_key(user_id, auth, &ce_key)) return false;
Paul Crowley05720802016-02-08 15:55:41 +0000204 std::string ce_raw_ref;
Paul Crowleyf71ace32016-06-02 11:01:19 -0700205 if (!android::vold::installKey(ce_key, &ce_raw_ref)) return false;
Pavel Grafove2e2d302017-08-01 17:15:53 +0100206 s_ce_keys[user_id] = std::move(ce_key);
Paul Crowley05720802016-02-08 15:55:41 +0000207 s_ce_key_raw_refs[user_id] = ce_raw_ref;
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000208 LOG(DEBUG) << "Installed ce key for user " << user_id;
Paul Crowley1ef25582016-01-21 20:26:12 +0000209 return true;
Paul Crowley285956f2016-01-20 13:12:38 +0000210}
211
Paul Crowleydf528a72016-03-09 09:31:37 -0800212static bool prepare_dir(const std::string& dir, mode_t mode, uid_t uid, gid_t gid) {
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000213 LOG(DEBUG) << "Preparing: " << dir;
Paul Crowley13ffd8e2016-01-27 14:30:22 +0000214 if (fs_prepare_dir(dir.c_str(), mode, uid, gid) != 0) {
215 PLOG(ERROR) << "Failed to prepare " << dir;
Paul Crowley285956f2016-01-20 13:12:38 +0000216 return false;
217 }
Paul Crowley13ffd8e2016-01-27 14:30:22 +0000218 return true;
219}
220
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600221static bool destroy_dir(const std::string& dir) {
222 LOG(DEBUG) << "Destroying: " << dir;
223 if (rmdir(dir.c_str()) != 0 && errno != ENOENT) {
224 PLOG(ERROR) << "Failed to destroy " << dir;
225 return false;
226 }
227 return true;
228}
229
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000230// NB this assumes that there is only one thread listening for crypt commands, because
231// it creates keys in a fixed location.
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000232static bool create_and_install_user_keys(userid_t user_id, bool create_ephemeral) {
Pavel Grafove2e2d302017-08-01 17:15:53 +0100233 KeyBuffer de_key, ce_key;
Paul Crowleyf71ace32016-06-02 11:01:19 -0700234 if (!android::vold::randomKey(&de_key)) return false;
235 if (!android::vold::randomKey(&ce_key)) return false;
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000236 if (create_ephemeral) {
237 // If the key should be created as ephemeral, don't store it.
238 s_ephemeral_users.insert(user_id);
239 } else {
Paul Crowleya3630362016-05-17 14:17:56 -0700240 auto const directory_path = get_ce_key_directory_path(user_id);
241 if (!prepare_dir(directory_path, 0700, AID_ROOT, AID_ROOT)) return false;
242 auto const paths = get_ce_key_paths(directory_path);
243 std::string ce_key_path;
244 if (!get_ce_key_new_path(directory_path, paths, &ce_key_path)) return false;
Paul Crowleyf71ace32016-06-02 11:01:19 -0700245 if (!android::vold::storeKeyAtomically(ce_key_path, user_key_temp,
Paul Crowleya3630362016-05-17 14:17:56 -0700246 kEmptyAuthentication, ce_key)) return false;
247 fixate_user_ce_key(directory_path, ce_key_path, paths);
248 // Write DE key second; once this is written, all is good.
Paul Crowleyf71ace32016-06-02 11:01:19 -0700249 if (!android::vold::storeKeyAtomically(get_de_key_path(user_id), user_key_temp,
Paul Crowley38132a12016-02-09 09:50:32 +0000250 kEmptyAuthentication, de_key)) return false;
Paul Crowley95376d62015-05-06 15:04:43 +0100251 }
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000252 std::string de_raw_ref;
Paul Crowleyf71ace32016-06-02 11:01:19 -0700253 if (!android::vold::installKey(de_key, &de_raw_ref)) return false;
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000254 s_de_key_raw_refs[user_id] = de_raw_ref;
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000255 std::string ce_raw_ref;
Paul Crowleyf71ace32016-06-02 11:01:19 -0700256 if (!android::vold::installKey(ce_key, &ce_raw_ref)) return false;
Paul Crowley05720802016-02-08 15:55:41 +0000257 s_ce_keys[user_id] = ce_key;
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000258 s_ce_key_raw_refs[user_id] = ce_raw_ref;
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000259 LOG(DEBUG) << "Created keys for user " << user_id;
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000260 return true;
261}
262
Paul Crowleydf528a72016-03-09 09:31:37 -0800263static bool lookup_key_ref(const std::map<userid_t, std::string>& key_map, userid_t user_id,
264 std::string* raw_ref) {
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000265 auto refi = key_map.find(user_id);
266 if (refi == key_map.end()) {
267 LOG(ERROR) << "Cannot find key for " << user_id;
268 return false;
269 }
Paul Crowleya051eb72016-03-08 16:08:32 -0800270 *raw_ref = refi->second;
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000271 return true;
272}
273
Paul Crowley3aa914d2017-10-09 16:35:51 -0700274static void get_data_file_encryption_modes(PolicyKeyRef* key_ref) {
Paul Crowleya7ca40b2017-10-06 14:29:33 -0700275 struct fstab_rec* rec = fs_mgr_get_entry_for_mount_point(fstab_default, DATA_MNT_POINT);
Paul Crowley3aa914d2017-10-09 16:35:51 -0700276 char const* contents_mode;
277 char const* filenames_mode;
278 fs_mgr_get_file_encryption_modes(rec, &contents_mode, &filenames_mode);
279 key_ref->contents_mode = contents_mode;
280 key_ref->filenames_mode = filenames_mode;
Paul Crowleya7ca40b2017-10-06 14:29:33 -0700281}
282
Paul Crowley3aa914d2017-10-09 16:35:51 -0700283static bool ensure_policy(const PolicyKeyRef& key_ref, const std::string& path) {
284 return e4crypt_policy_ensure(path.c_str(), key_ref.key_raw_ref.data(),
285 key_ref.key_raw_ref.size(), key_ref.contents_mode.c_str(),
286 key_ref.filenames_mode.c_str()) == 0;
Paul Crowley95376d62015-05-06 15:04:43 +0100287}
Paul Crowleyb33e8872015-05-19 12:34:09 +0100288
Paul Crowleydf528a72016-03-09 09:31:37 -0800289static bool is_numeric(const char* name) {
290 for (const char* p = name; *p != '\0'; p++) {
291 if (!isdigit(*p)) return false;
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000292 }
293 return true;
294}
295
296static bool load_all_de_keys() {
297 auto de_dir = user_key_dir + "/de";
Paul Crowleydf528a72016-03-09 09:31:37 -0800298 auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(de_dir.c_str()), closedir);
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000299 if (!dirp) {
300 PLOG(ERROR) << "Unable to read de key directory";
301 return false;
302 }
303 for (;;) {
304 errno = 0;
305 auto entry = readdir(dirp.get());
306 if (!entry) {
307 if (errno) {
308 PLOG(ERROR) << "Unable to read de key directory";
309 return false;
310 }
311 break;
312 }
313 if (entry->d_type != DT_DIR || !is_numeric(entry->d_name)) {
314 LOG(DEBUG) << "Skipping non-de-key " << entry->d_name;
315 continue;
316 }
Jeff Sharkey95440eb2017-09-18 18:19:28 -0600317 userid_t user_id = std::stoi(entry->d_name);
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000318 if (s_de_key_raw_refs.count(user_id) == 0) {
Paul Crowley05720802016-02-08 15:55:41 +0000319 auto key_path = de_dir + "/" + entry->d_name;
Pavel Grafove2e2d302017-08-01 17:15:53 +0100320 KeyBuffer key;
Paul Crowleya051eb72016-03-08 16:08:32 -0800321 if (!android::vold::retrieveKey(key_path, kEmptyAuthentication, &key)) return false;
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000322 std::string raw_ref;
Paul Crowleyf71ace32016-06-02 11:01:19 -0700323 if (!android::vold::installKey(key, &raw_ref)) return false;
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000324 s_de_key_raw_refs[user_id] = raw_ref;
325 LOG(DEBUG) << "Installed de key for user " << user_id;
326 }
327 }
328 // ext4enc:TODO: go through all DE directories, ensure that all user dirs have the
329 // correct policy set on them, and that no rogue ones exist.
330 return true;
331}
332
Paul Crowleydf528a72016-03-09 09:31:37 -0800333bool e4crypt_initialize_global_de() {
Paul Crowley38132a12016-02-09 09:50:32 +0000334 LOG(INFO) << "e4crypt_initialize_global_de";
Paul Lawrenceaec34df2016-02-03 10:52:41 -0800335
Paul Crowley38132a12016-02-09 09:50:32 +0000336 if (s_global_de_initialized) {
337 LOG(INFO) << "Already initialized";
Paul Crowley76107cb2016-02-09 10:04:39 +0000338 return true;
Paul Lawrenceaec34df2016-02-03 10:52:41 -0800339 }
340
Paul Crowley3aa914d2017-10-09 16:35:51 -0700341 PolicyKeyRef device_ref;
Paul Crowley26a53882017-10-26 11:16:39 -0700342 if (!android::vold::retrieveAndInstallKey(true, kEmptyAuthentication, device_key_path,
343 device_key_temp, &device_ref.key_raw_ref))
Paul Crowley3aa914d2017-10-09 16:35:51 -0700344 return false;
345 get_data_file_encryption_modes(&device_ref);
Eric Biggersb45caaf2017-02-02 14:52:12 -0800346
Paul Crowley3aa914d2017-10-09 16:35:51 -0700347 std::string modestring = device_ref.contents_mode + ":" + device_ref.filenames_mode;
Paul Lawrence6e410592016-05-24 14:20:38 -0700348 std::string mode_filename = std::string("/data") + e4crypt_key_mode;
Eric Biggersb45caaf2017-02-02 14:52:12 -0800349 if (!android::base::WriteStringToFile(modestring, mode_filename)) {
Paul Lawrence6e410592016-05-24 14:20:38 -0700350 PLOG(ERROR) << "Cannot save type";
351 return false;
352 }
353
Paul Lawrencef10544d2016-02-04 08:18:52 -0800354 std::string ref_filename = std::string("/data") + e4crypt_key_ref;
Paul Crowley3aa914d2017-10-09 16:35:51 -0700355 if (!android::base::WriteStringToFile(device_ref.key_raw_ref, ref_filename)) {
Paul Crowleyf71ace32016-06-02 11:01:19 -0700356 PLOG(ERROR) << "Cannot save key reference to:" << ref_filename;
Paul Crowley76107cb2016-02-09 10:04:39 +0000357 return false;
Paul Lawrenceaec34df2016-02-03 10:52:41 -0800358 }
Paul Crowleyf71ace32016-06-02 11:01:19 -0700359 LOG(INFO) << "Wrote system DE key reference to:" << ref_filename;
Paul Lawrenceaec34df2016-02-03 10:52:41 -0800360
Paul Crowley38132a12016-02-09 09:50:32 +0000361 s_global_de_initialized = true;
Paul Crowley76107cb2016-02-09 10:04:39 +0000362 return true;
Paul Lawrenceaec34df2016-02-03 10:52:41 -0800363}
364
Paul Crowley76107cb2016-02-09 10:04:39 +0000365bool e4crypt_init_user0() {
Paul Crowley8fb12fd2016-02-01 14:28:12 +0000366 LOG(DEBUG) << "e4crypt_init_user0";
367 if (e4crypt_is_native()) {
Paul Crowley76107cb2016-02-09 10:04:39 +0000368 if (!prepare_dir(user_key_dir, 0700, AID_ROOT, AID_ROOT)) return false;
369 if (!prepare_dir(user_key_dir + "/ce", 0700, AID_ROOT, AID_ROOT)) return false;
370 if (!prepare_dir(user_key_dir + "/de", 0700, AID_ROOT, AID_ROOT)) return false;
Paul Crowleyf71ace32016-06-02 11:01:19 -0700371 if (!android::vold::pathExists(get_de_key_path(0))) {
Paul Crowley76107cb2016-02-09 10:04:39 +0000372 if (!create_and_install_user_keys(0, false)) return false;
Paul Crowley8fb12fd2016-02-01 14:28:12 +0000373 }
Jeff Sharkey47695b22016-02-01 17:02:29 -0700374 // TODO: switch to loading only DE_0 here once framework makes
375 // explicit calls to install DE keys for secondary users
Paul Crowley76107cb2016-02-09 10:04:39 +0000376 if (!load_all_de_keys()) return false;
Paul Crowley8fb12fd2016-02-01 14:28:12 +0000377 }
Jeff Sharkey47695b22016-02-01 17:02:29 -0700378 // We can only safely prepare DE storage here, since CE keys are probably
379 // entangled with user credentials. The framework will always prepare CE
380 // storage once CE keys are installed.
Paul Crowley82b41ff2017-10-20 08:17:54 -0700381 if (!e4crypt_prepare_user_storage("", 0, 0, android::os::IVold::STORAGE_FLAG_DE)) {
Jeff Sharkey47695b22016-02-01 17:02:29 -0700382 LOG(ERROR) << "Failed to prepare user 0 storage";
Paul Crowley76107cb2016-02-09 10:04:39 +0000383 return false;
Jeff Sharkey47695b22016-02-01 17:02:29 -0700384 }
Jeff Sharkey0754a452016-02-08 12:21:42 -0700385
386 // If this is a non-FBE device that recently left an emulated mode,
387 // restore user data directories to known-good state.
388 if (!e4crypt_is_native() && !e4crypt_is_emulated()) {
Jeff Sharkey695d9282016-02-08 18:10:34 -0700389 e4crypt_unlock_user_key(0, 0, "!", "!");
Jeff Sharkey0754a452016-02-08 12:21:42 -0700390 }
391
Paul Crowley76107cb2016-02-09 10:04:39 +0000392 return true;
Paul Crowley8fb12fd2016-02-01 14:28:12 +0000393}
394
Paul Crowley76107cb2016-02-09 10:04:39 +0000395bool e4crypt_vold_create_user_key(userid_t user_id, int serial, bool ephemeral) {
Paul Crowley285956f2016-01-20 13:12:38 +0000396 LOG(DEBUG) << "e4crypt_vold_create_user_key for " << user_id << " serial " << serial;
Paul Crowleyea62e262016-01-28 12:23:53 +0000397 if (!e4crypt_is_native()) {
Paul Crowley76107cb2016-02-09 10:04:39 +0000398 return true;
Paul Crowleyea62e262016-01-28 12:23:53 +0000399 }
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000400 // FIXME test for existence of key that is not loaded yet
401 if (s_ce_key_raw_refs.count(user_id) != 0) {
Paul Crowleydf528a72016-03-09 09:31:37 -0800402 LOG(ERROR) << "Already exists, can't e4crypt_vold_create_user_key for " << user_id
403 << " serial " << serial;
Paul Crowley285956f2016-01-20 13:12:38 +0000404 // FIXME should we fail the command?
Paul Crowley76107cb2016-02-09 10:04:39 +0000405 return true;
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800406 }
Paul Crowleyb92f83c2016-02-01 14:10:43 +0000407 if (!create_and_install_user_keys(user_id, ephemeral)) {
Paul Crowley76107cb2016-02-09 10:04:39 +0000408 return false;
Paul Crowley285956f2016-01-20 13:12:38 +0000409 }
Paul Crowley76107cb2016-02-09 10:04:39 +0000410 return true;
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800411}
412
Pavel Grafovb350ed02017-07-27 17:34:57 +0100413static void drop_caches() {
414 // Clean any dirty pages (otherwise they won't be dropped).
415 sync();
416 // Drop inode and page caches.
417 if (!WriteStringToFile("3", "/proc/sys/vm/drop_caches")) {
418 PLOG(ERROR) << "Failed to drop caches during key eviction";
419 }
420}
421
Andrew Scull7ec25c72016-10-31 10:28:25 +0000422static bool evict_ce_key(userid_t user_id) {
Pavel Grafove2e2d302017-08-01 17:15:53 +0100423 s_ce_keys.erase(user_id);
Andrew Scull7ec25c72016-10-31 10:28:25 +0000424 bool success = true;
425 std::string raw_ref;
426 // If we haven't loaded the CE key, no need to evict it.
427 if (lookup_key_ref(s_ce_key_raw_refs, user_id, &raw_ref)) {
Paul Crowleyf71ace32016-06-02 11:01:19 -0700428 success &= android::vold::evictKey(raw_ref);
Pavel Grafovb350ed02017-07-27 17:34:57 +0100429 drop_caches();
Andrew Scull7ec25c72016-10-31 10:28:25 +0000430 }
431 s_ce_key_raw_refs.erase(user_id);
432 return success;
433}
434
Paul Crowley76107cb2016-02-09 10:04:39 +0000435bool e4crypt_destroy_user_key(userid_t user_id) {
Paul Crowley1ef25582016-01-21 20:26:12 +0000436 LOG(DEBUG) << "e4crypt_destroy_user_key(" << user_id << ")";
Paul Crowleyea62e262016-01-28 12:23:53 +0000437 if (!e4crypt_is_native()) {
Paul Crowley76107cb2016-02-09 10:04:39 +0000438 return true;
Paul Crowleyea62e262016-01-28 12:23:53 +0000439 }
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000440 bool success = true;
441 std::string raw_ref;
Andrew Scull7ec25c72016-10-31 10:28:25 +0000442 success &= evict_ce_key(user_id);
Paul Crowleyf71ace32016-06-02 11:01:19 -0700443 success &= lookup_key_ref(s_de_key_raw_refs, user_id, &raw_ref)
444 && android::vold::evictKey(raw_ref);
Paul Crowley05720802016-02-08 15:55:41 +0000445 s_de_key_raw_refs.erase(user_id);
Paul Crowleyb1f3d242016-01-28 10:09:46 +0000446 auto it = s_ephemeral_users.find(user_id);
447 if (it != s_ephemeral_users.end()) {
448 s_ephemeral_users.erase(it);
Paul Crowley1ef25582016-01-21 20:26:12 +0000449 } else {
Paul Crowleya3630362016-05-17 14:17:56 -0700450 for (auto const path: get_ce_key_paths(get_ce_key_directory_path(user_id))) {
451 success &= android::vold::destroyKey(path);
452 }
Paul Crowleyab0b56a2016-07-19 15:29:53 -0700453 auto de_key_path = get_de_key_path(user_id);
Paul Crowleyf71ace32016-06-02 11:01:19 -0700454 if (android::vold::pathExists(de_key_path)) {
Paul Crowleyab0b56a2016-07-19 15:29:53 -0700455 success &= android::vold::destroyKey(de_key_path);
456 } else {
457 LOG(INFO) << "Not present so not erasing: " << de_key_path;
458 }
Lenka Trochtova395039f2015-11-25 10:13:03 +0100459 }
Paul Crowley76107cb2016-02-09 10:04:39 +0000460 return success;
Paul Crowleyb33e8872015-05-19 12:34:09 +0100461}
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800462
Paul Crowley76107cb2016-02-09 10:04:39 +0000463static bool emulated_lock(const std::string& path) {
Jeff Sharkey7a9dd952016-01-12 16:52:16 -0700464 if (chmod(path.c_str(), 0000) != 0) {
465 PLOG(ERROR) << "Failed to chmod " << path;
Paul Crowley76107cb2016-02-09 10:04:39 +0000466 return false;
Jeff Sharkey7a9dd952016-01-12 16:52:16 -0700467 }
468#if EMULATED_USES_SELINUX
469 if (setfilecon(path.c_str(), "u:object_r:storage_stub_file:s0") != 0) {
470 PLOG(WARNING) << "Failed to setfilecon " << path;
Paul Crowley76107cb2016-02-09 10:04:39 +0000471 return false;
Jeff Sharkey7a9dd952016-01-12 16:52:16 -0700472 }
473#endif
Paul Crowley76107cb2016-02-09 10:04:39 +0000474 return true;
Jeff Sharkey7a9dd952016-01-12 16:52:16 -0700475}
476
Paul Crowley76107cb2016-02-09 10:04:39 +0000477static bool emulated_unlock(const std::string& path, mode_t mode) {
Jeff Sharkey7a9dd952016-01-12 16:52:16 -0700478 if (chmod(path.c_str(), mode) != 0) {
479 PLOG(ERROR) << "Failed to chmod " << path;
Paul Crowleya042cb52016-01-21 17:24:49 +0000480 // FIXME temporary workaround for b/26713622
Paul Crowley76107cb2016-02-09 10:04:39 +0000481 if (e4crypt_is_emulated()) return false;
Jeff Sharkey7a9dd952016-01-12 16:52:16 -0700482 }
483#if EMULATED_USES_SELINUX
484 if (selinux_android_restorecon(path.c_str(), SELINUX_ANDROID_RESTORECON_FORCE) != 0) {
485 PLOG(WARNING) << "Failed to restorecon " << path;
Paul Crowleya042cb52016-01-21 17:24:49 +0000486 // FIXME temporary workaround for b/26713622
Paul Crowley76107cb2016-02-09 10:04:39 +0000487 if (e4crypt_is_emulated()) return false;
Jeff Sharkey7a9dd952016-01-12 16:52:16 -0700488 }
489#endif
Paul Crowley76107cb2016-02-09 10:04:39 +0000490 return true;
Jeff Sharkey7a9dd952016-01-12 16:52:16 -0700491}
492
Paul Crowley3b71fc52017-10-09 10:55:21 -0700493static bool parse_hex(const std::string& hex, std::string* result) {
494 if (hex == "!") {
Paul Crowleya051eb72016-03-08 16:08:32 -0800495 *result = "";
Paul Crowley05720802016-02-08 15:55:41 +0000496 return true;
497 }
Paul Crowleya051eb72016-03-08 16:08:32 -0800498 if (android::vold::HexToStr(hex, *result) != 0) {
Paul Crowleydf528a72016-03-09 09:31:37 -0800499 LOG(ERROR) << "Invalid FBE hex string"; // Don't log the string for security reasons
Paul Crowley05720802016-02-08 15:55:41 +0000500 return false;
501 }
502 return true;
503}
504
Paul Crowley3aa914d2017-10-09 16:35:51 -0700505static std::string volkey_path(const std::string& misc_path, const std::string& volume_uuid) {
506 return misc_path + "/vold/volume_keys/" + volume_uuid + "/default";
507}
508
Paul Crowley26a53882017-10-26 11:16:39 -0700509static std::string volume_secdiscardable_path(const std::string& volume_uuid) {
510 return systemwide_volume_key_dir + "/" + volume_uuid + "/secdiscardable";
511}
512
Paul Crowley3aa914d2017-10-09 16:35:51 -0700513static bool read_or_create_volkey(const std::string& misc_path, const std::string& volume_uuid,
514 PolicyKeyRef* key_ref) {
Paul Crowley26a53882017-10-26 11:16:39 -0700515 auto secdiscardable_path = volume_secdiscardable_path(volume_uuid);
516 std::string secdiscardable_hash;
517 if (android::vold::pathExists(secdiscardable_path)) {
518 if (!android::vold::readSecdiscardable(secdiscardable_path, &secdiscardable_hash))
519 return false;
520 } else {
521 if (fs_mkdirs(secdiscardable_path.c_str(), 0700) != 0) {
522 PLOG(ERROR) << "Creating directories for: " << secdiscardable_path;
523 return false;
524 }
525 if (!android::vold::createSecdiscardable(secdiscardable_path, &secdiscardable_hash))
526 return false;
527 }
Paul Crowley3aa914d2017-10-09 16:35:51 -0700528 auto key_path = volkey_path(misc_path, volume_uuid);
529 if (fs_mkdirs(key_path.c_str(), 0700) != 0) {
530 PLOG(ERROR) << "Creating directories for: " << key_path;
531 return false;
532 }
Paul Crowley26a53882017-10-26 11:16:39 -0700533 android::vold::KeyAuthentication auth("", secdiscardable_hash);
534 if (!android::vold::retrieveAndInstallKey(true, auth, key_path, key_path + "_tmp",
Paul Crowley3aa914d2017-10-09 16:35:51 -0700535 &key_ref->key_raw_ref))
536 return false;
537 key_ref->contents_mode =
538 android::base::GetProperty("ro.crypto.volume.contents_mode", "aes-256-xts");
539 key_ref->filenames_mode =
540 android::base::GetProperty("ro.crypto.volume.filenames_mode", "aes-256-heh");
541 return true;
542}
543
544static bool destroy_volkey(const std::string& misc_path, const std::string& volume_uuid) {
Paul Crowleyc6433a22017-10-24 14:54:43 -0700545 auto path = volkey_path(misc_path, volume_uuid);
546 if (!android::vold::pathExists(path)) return true;
547 return android::vold::destroyKey(path);
Paul Crowley3aa914d2017-10-09 16:35:51 -0700548}
549
Paul Crowley3b71fc52017-10-09 10:55:21 -0700550bool e4crypt_add_user_key_auth(userid_t user_id, int serial, const std::string& token_hex,
551 const std::string& secret_hex) {
Paul Crowleya3630362016-05-17 14:17:56 -0700552 LOG(DEBUG) << "e4crypt_add_user_key_auth " << user_id << " serial=" << serial
Paul Crowley3b71fc52017-10-09 10:55:21 -0700553 << " token_present=" << (token_hex != "!");
Paul Crowley76107cb2016-02-09 10:04:39 +0000554 if (!e4crypt_is_native()) return true;
555 if (s_ephemeral_users.count(user_id) != 0) return true;
Paul Crowleya3630362016-05-17 14:17:56 -0700556 std::string token, secret;
Paul Crowleya051eb72016-03-08 16:08:32 -0800557 if (!parse_hex(token_hex, &token)) return false;
Paul Crowleya3630362016-05-17 14:17:56 -0700558 if (!parse_hex(secret_hex, &secret)) return false;
559 auto auth = secret.empty() ? kEmptyAuthentication
560 : android::vold::KeyAuthentication(token, secret);
Paul Crowley05720802016-02-08 15:55:41 +0000561 auto it = s_ce_keys.find(user_id);
562 if (it == s_ce_keys.end()) {
563 LOG(ERROR) << "Key not loaded into memory, can't change for user " << user_id;
Paul Crowley76107cb2016-02-09 10:04:39 +0000564 return false;
Paul Crowley05720802016-02-08 15:55:41 +0000565 }
Pavel Grafove2e2d302017-08-01 17:15:53 +0100566 const auto &ce_key = it->second;
Paul Crowleya3630362016-05-17 14:17:56 -0700567 auto const directory_path = get_ce_key_directory_path(user_id);
568 auto const paths = get_ce_key_paths(directory_path);
569 std::string ce_key_path;
570 if (!get_ce_key_new_path(directory_path, paths, &ce_key_path)) return false;
Paul Crowleyf71ace32016-06-02 11:01:19 -0700571 if (!android::vold::storeKeyAtomically(ce_key_path, user_key_temp, auth, ce_key)) return false;
Paul Crowleya3630362016-05-17 14:17:56 -0700572 return true;
573}
574
575bool e4crypt_fixate_newest_user_key_auth(userid_t user_id) {
576 LOG(DEBUG) << "e4crypt_fixate_newest_user_key_auth " << user_id;
577 if (!e4crypt_is_native()) return true;
Paul Crowley25a71382016-07-25 15:55:36 -0700578 if (s_ephemeral_users.count(user_id) != 0) return true;
Paul Crowleya3630362016-05-17 14:17:56 -0700579 auto const directory_path = get_ce_key_directory_path(user_id);
580 auto const paths = get_ce_key_paths(directory_path);
581 if (paths.empty()) {
582 LOG(ERROR) << "No ce keys present, cannot fixate for user " << user_id;
583 return false;
Paul Crowleyad2eb642016-02-10 17:56:05 +0000584 }
Paul Crowleya3630362016-05-17 14:17:56 -0700585 fixate_user_ce_key(directory_path, paths[0], paths);
Paul Crowley76107cb2016-02-09 10:04:39 +0000586 return true;
Paul Crowley05720802016-02-08 15:55:41 +0000587}
588
Jeff Sharkey47695b22016-02-01 17:02:29 -0700589// TODO: rename to 'install' for consistency, and take flags to know which keys to install
Paul Crowley3b71fc52017-10-09 10:55:21 -0700590bool e4crypt_unlock_user_key(userid_t user_id, int serial, const std::string& token_hex,
591 const std::string& secret_hex) {
Paul Crowleydf528a72016-03-09 09:31:37 -0800592 LOG(DEBUG) << "e4crypt_unlock_user_key " << user_id << " serial=" << serial
Paul Crowley3b71fc52017-10-09 10:55:21 -0700593 << " token_present=" << (token_hex != "!");
Jeff Sharkeyfc505c32015-12-07 17:27:01 -0700594 if (e4crypt_is_native()) {
Paul Crowley05720802016-02-08 15:55:41 +0000595 if (s_ce_key_raw_refs.count(user_id) != 0) {
596 LOG(WARNING) << "Tried to unlock already-unlocked key for user " << user_id;
Paul Crowley76107cb2016-02-09 10:04:39 +0000597 return true;
Paul Crowley05720802016-02-08 15:55:41 +0000598 }
599 std::string token, secret;
Paul Crowleya051eb72016-03-08 16:08:32 -0800600 if (!parse_hex(token_hex, &token)) return false;
601 if (!parse_hex(secret_hex, &secret)) return false;
Paul Crowley05720802016-02-08 15:55:41 +0000602 android::vold::KeyAuthentication auth(token, secret);
603 if (!read_and_install_user_ce_key(user_id, auth)) {
Paul Crowley8fb12fd2016-02-01 14:28:12 +0000604 LOG(ERROR) << "Couldn't read key for " << user_id;
Paul Crowley76107cb2016-02-09 10:04:39 +0000605 return false;
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800606 }
Jeff Sharkeyfc505c32015-12-07 17:27:01 -0700607 } else {
608 // When in emulation mode, we just use chmod. However, we also
609 // unlock directories when not in emulation mode, to bring devices
610 // back into a known-good state.
Paul Crowley76107cb2016-02-09 10:04:39 +0000611 if (!emulated_unlock(android::vold::BuildDataSystemCePath(user_id), 0771) ||
Paul Crowleydf528a72016-03-09 09:31:37 -0800612 !emulated_unlock(android::vold::BuildDataMiscCePath(user_id), 01771) ||
Paul Crowley3b71fc52017-10-09 10:55:21 -0700613 !emulated_unlock(android::vold::BuildDataMediaCePath("", user_id), 0770) ||
614 !emulated_unlock(android::vold::BuildDataUserCePath("", user_id), 0771)) {
Jeff Sharkey7a9dd952016-01-12 16:52:16 -0700615 LOG(ERROR) << "Failed to unlock user " << user_id;
Paul Crowley76107cb2016-02-09 10:04:39 +0000616 return false;
Jeff Sharkeyfc505c32015-12-07 17:27:01 -0700617 }
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800618 }
Paul Crowley76107cb2016-02-09 10:04:39 +0000619 return true;
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800620}
621
Jeff Sharkey47695b22016-02-01 17:02:29 -0700622// TODO: rename to 'evict' for consistency
Paul Crowley76107cb2016-02-09 10:04:39 +0000623bool e4crypt_lock_user_key(userid_t user_id) {
Andrew Scull7ec25c72016-10-31 10:28:25 +0000624 LOG(DEBUG) << "e4crypt_lock_user_key " << user_id;
Jeff Sharkeyfc505c32015-12-07 17:27:01 -0700625 if (e4crypt_is_native()) {
Andrew Scull7ec25c72016-10-31 10:28:25 +0000626 return evict_ce_key(user_id);
Jeff Sharkeyfc505c32015-12-07 17:27:01 -0700627 } else if (e4crypt_is_emulated()) {
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800628 // When in emulation mode, we just use chmod
Paul Crowley76107cb2016-02-09 10:04:39 +0000629 if (!emulated_lock(android::vold::BuildDataSystemCePath(user_id)) ||
Paul Crowleydf528a72016-03-09 09:31:37 -0800630 !emulated_lock(android::vold::BuildDataMiscCePath(user_id)) ||
Paul Crowley3b71fc52017-10-09 10:55:21 -0700631 !emulated_lock(android::vold::BuildDataMediaCePath("", user_id)) ||
632 !emulated_lock(android::vold::BuildDataUserCePath("", user_id))) {
Paul Crowley57eedbf2016-02-09 09:30:23 +0000633 LOG(ERROR) << "Failed to lock user " << user_id;
Paul Crowley76107cb2016-02-09 10:04:39 +0000634 return false;
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800635 }
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800636 }
Jeff Sharkeyfc505c32015-12-07 17:27:01 -0700637
Paul Crowley76107cb2016-02-09 10:04:39 +0000638 return true;
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800639}
640
Paul Crowley82b41ff2017-10-20 08:17:54 -0700641static bool prepare_subdirs(const std::string& action, const std::string& volume_uuid,
642 userid_t user_id, int flags) {
643 if (0 != android::vold::ForkExecvp(
644 std::vector<std::string>{prepare_subdirs_path, action, volume_uuid,
645 std::to_string(user_id), std::to_string(flags)})) {
646 LOG(ERROR) << "vold_prepare_subdirs failed";
Paul Crowley8e550662017-10-16 17:01:44 -0700647 return false;
648 }
649 return true;
650}
651
Paul Crowley3b71fc52017-10-09 10:55:21 -0700652bool e4crypt_prepare_user_storage(const std::string& volume_uuid, userid_t user_id, int serial,
653 int flags) {
654 LOG(DEBUG) << "e4crypt_prepare_user_storage for volume " << escape_empty(volume_uuid)
Paul Crowleydf528a72016-03-09 09:31:37 -0800655 << ", user " << user_id << ", serial " << serial << ", flags " << flags;
Jeff Sharkey47695b22016-02-01 17:02:29 -0700656
Paul Crowley82b41ff2017-10-20 08:17:54 -0700657 if (flags & android::os::IVold::STORAGE_FLAG_DE) {
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600658 // DE_sys key
659 auto system_legacy_path = android::vold::BuildDataSystemLegacyPath(user_id);
660 auto misc_legacy_path = android::vold::BuildDataMiscLegacyPath(user_id);
661 auto profiles_de_path = android::vold::BuildDataProfilesDePath(user_id);
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600662
663 // DE_n key
Jeff Sharkey47695b22016-02-01 17:02:29 -0700664 auto system_de_path = android::vold::BuildDataSystemDePath(user_id);
665 auto misc_de_path = android::vold::BuildDataMiscDePath(user_id);
666 auto user_de_path = android::vold::BuildDataUserDePath(volume_uuid, user_id);
667
Paul Crowley3b71fc52017-10-09 10:55:21 -0700668 if (volume_uuid.empty()) {
Paul Crowley6b756ce2017-10-05 14:07:09 -0700669 if (!prepare_dir(system_legacy_path, 0700, AID_SYSTEM, AID_SYSTEM)) return false;
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600670#if MANAGE_MISC_DIRS
Paul Crowley6b756ce2017-10-05 14:07:09 -0700671 if (!prepare_dir(misc_legacy_path, 0750, multiuser_get_uid(user_id, AID_SYSTEM),
672 multiuser_get_uid(user_id, AID_EVERYBODY))) return false;
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600673#endif
Paul Crowley6b756ce2017-10-05 14:07:09 -0700674 if (!prepare_dir(profiles_de_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600675
Paul Crowley6b756ce2017-10-05 14:07:09 -0700676 if (!prepare_dir(system_de_path, 0770, AID_SYSTEM, AID_SYSTEM)) return false;
677 if (!prepare_dir(misc_de_path, 01771, AID_SYSTEM, AID_MISC)) return false;
678 }
Paul Crowley76107cb2016-02-09 10:04:39 +0000679 if (!prepare_dir(user_de_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
Calin Juravled1ee9442016-03-02 18:36:50 +0000680
Jeff Sharkeyd7945262017-06-26 16:09:11 -0600681 if (e4crypt_is_native()) {
Paul Crowley3aa914d2017-10-09 16:35:51 -0700682 PolicyKeyRef de_ref;
Paul Crowley3b71fc52017-10-09 10:55:21 -0700683 if (volume_uuid.empty()) {
Paul Crowley3aa914d2017-10-09 16:35:51 -0700684 if (!lookup_key_ref(s_de_key_raw_refs, user_id, &de_ref.key_raw_ref)) return false;
685 get_data_file_encryption_modes(&de_ref);
686 if (!ensure_policy(de_ref, system_de_path)) return false;
687 if (!ensure_policy(de_ref, misc_de_path)) return false;
688 } else {
689 if (!read_or_create_volkey(misc_de_path, volume_uuid, &de_ref)) return false;
Paul Crowley6b756ce2017-10-05 14:07:09 -0700690 }
Paul Crowley3aa914d2017-10-09 16:35:51 -0700691 if (!ensure_policy(de_ref, user_de_path)) return false;
Jeff Sharkey47695b22016-02-01 17:02:29 -0700692 }
Paul Crowley285956f2016-01-20 13:12:38 +0000693 }
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800694
Paul Crowley82b41ff2017-10-20 08:17:54 -0700695 if (flags & android::os::IVold::STORAGE_FLAG_CE) {
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600696 // CE_n key
Jeff Sharkey47695b22016-02-01 17:02:29 -0700697 auto system_ce_path = android::vold::BuildDataSystemCePath(user_id);
698 auto misc_ce_path = android::vold::BuildDataMiscCePath(user_id);
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600699 auto media_ce_path = android::vold::BuildDataMediaCePath(volume_uuid, user_id);
700 auto user_ce_path = android::vold::BuildDataUserCePath(volume_uuid, user_id);
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800701
Paul Crowley3b71fc52017-10-09 10:55:21 -0700702 if (volume_uuid.empty()) {
Paul Crowley6b756ce2017-10-05 14:07:09 -0700703 if (!prepare_dir(system_ce_path, 0770, AID_SYSTEM, AID_SYSTEM)) return false;
704 if (!prepare_dir(misc_ce_path, 01771, AID_SYSTEM, AID_MISC)) return false;
705 }
Paul Crowley76107cb2016-02-09 10:04:39 +0000706 if (!prepare_dir(media_ce_path, 0770, AID_MEDIA_RW, AID_MEDIA_RW)) return false;
707 if (!prepare_dir(user_ce_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
Jeff Sharkey47695b22016-02-01 17:02:29 -0700708
Jeff Sharkeyd7945262017-06-26 16:09:11 -0600709 if (e4crypt_is_native()) {
Paul Crowley3aa914d2017-10-09 16:35:51 -0700710 PolicyKeyRef ce_ref;
Paul Crowley3b71fc52017-10-09 10:55:21 -0700711 if (volume_uuid.empty()) {
Paul Crowley3aa914d2017-10-09 16:35:51 -0700712 if (!lookup_key_ref(s_ce_key_raw_refs, user_id, &ce_ref.key_raw_ref)) return false;
713 get_data_file_encryption_modes(&ce_ref);
714 if (!ensure_policy(ce_ref, system_ce_path)) return false;
715 if (!ensure_policy(ce_ref, misc_ce_path)) return false;
Paul Crowley6b756ce2017-10-05 14:07:09 -0700716
Paul Crowley3aa914d2017-10-09 16:35:51 -0700717 } else {
718 if (!read_or_create_volkey(misc_ce_path, volume_uuid, &ce_ref)) return false;
Paul Crowley6b756ce2017-10-05 14:07:09 -0700719 }
Paul Crowley3aa914d2017-10-09 16:35:51 -0700720 if (!ensure_policy(ce_ref, media_ce_path)) return false;
721 if (!ensure_policy(ce_ref, user_ce_path)) return false;
Jeff Sharkey47695b22016-02-01 17:02:29 -0700722 }
Paul Crowley1a965262017-10-13 13:49:50 -0700723
724 if (volume_uuid.empty()) {
Paul Crowley8e550662017-10-16 17:01:44 -0700725 // Now that credentials have been installed, we can run restorecon
726 // over these paths
727 // NOTE: these paths need to be kept in sync with libselinux
728 android::vold::RestoreconRecursive(system_ce_path);
729 android::vold::RestoreconRecursive(misc_ce_path);
Paul Crowley1a965262017-10-13 13:49:50 -0700730 }
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800731 }
Paul Crowley82b41ff2017-10-20 08:17:54 -0700732 if (!prepare_subdirs("prepare", volume_uuid, user_id, flags)) return false;
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800733
Paul Crowley76107cb2016-02-09 10:04:39 +0000734 return true;
Jeff Sharkeyd2c96e72015-11-08 17:56:23 -0800735}
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600736
Paul Crowley3b71fc52017-10-09 10:55:21 -0700737bool e4crypt_destroy_user_storage(const std::string& volume_uuid, userid_t user_id, int flags) {
738 LOG(DEBUG) << "e4crypt_destroy_user_storage for volume " << escape_empty(volume_uuid)
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600739 << ", user " << user_id << ", flags " << flags;
740 bool res = true;
741
Paul Crowley82b41ff2017-10-20 08:17:54 -0700742 res &= prepare_subdirs("destroy", volume_uuid, user_id, flags);
743
744 if (flags & android::os::IVold::STORAGE_FLAG_CE) {
Paul Crowley8e550662017-10-16 17:01:44 -0700745 // CE_n key
746 auto system_ce_path = android::vold::BuildDataSystemCePath(user_id);
747 auto misc_ce_path = android::vold::BuildDataMiscCePath(user_id);
748 auto media_ce_path = android::vold::BuildDataMediaCePath(volume_uuid, user_id);
749 auto user_ce_path = android::vold::BuildDataUserCePath(volume_uuid, user_id);
750
751 res &= destroy_dir(media_ce_path);
752 res &= destroy_dir(user_ce_path);
753 if (volume_uuid.empty()) {
Paul Crowley8e550662017-10-16 17:01:44 -0700754 res &= destroy_dir(system_ce_path);
755 res &= destroy_dir(misc_ce_path);
Paul Crowley3aa914d2017-10-09 16:35:51 -0700756 } else {
757 if (e4crypt_is_native()) {
758 res &= destroy_volkey(misc_ce_path, volume_uuid);
759 }
Paul Crowley8e550662017-10-16 17:01:44 -0700760 }
761 }
762
Paul Crowley82b41ff2017-10-20 08:17:54 -0700763 if (flags & android::os::IVold::STORAGE_FLAG_DE) {
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600764 // DE_sys key
765 auto system_legacy_path = android::vold::BuildDataSystemLegacyPath(user_id);
766 auto misc_legacy_path = android::vold::BuildDataMiscLegacyPath(user_id);
767 auto profiles_de_path = android::vold::BuildDataProfilesDePath(user_id);
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600768
769 // DE_n key
770 auto system_de_path = android::vold::BuildDataSystemDePath(user_id);
771 auto misc_de_path = android::vold::BuildDataMiscDePath(user_id);
772 auto user_de_path = android::vold::BuildDataUserDePath(volume_uuid, user_id);
773
Paul Crowley8e550662017-10-16 17:01:44 -0700774 res &= destroy_dir(user_de_path);
Paul Crowley3b71fc52017-10-09 10:55:21 -0700775 if (volume_uuid.empty()) {
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600776 res &= destroy_dir(system_legacy_path);
777#if MANAGE_MISC_DIRS
778 res &= destroy_dir(misc_legacy_path);
779#endif
780 res &= destroy_dir(profiles_de_path);
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600781 res &= destroy_dir(system_de_path);
782 res &= destroy_dir(misc_de_path);
Paul Crowley3aa914d2017-10-09 16:35:51 -0700783 } else {
784 if (e4crypt_is_native()) {
785 res &= destroy_volkey(misc_de_path, volume_uuid);
786 }
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600787 }
Jeff Sharkeybe70c9a2016-04-14 20:45:16 -0600788 }
789
790 return res;
791}
Rubin Xu2436e272017-04-27 20:43:10 +0100792
Paul Crowleyc6433a22017-10-24 14:54:43 -0700793static bool destroy_volume_keys(const std::string& directory_path, const std::string& volume_uuid) {
794 auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(directory_path.c_str()), closedir);
795 if (!dirp) {
796 PLOG(ERROR) << "Unable to open directory: " + directory_path;
797 return false;
798 }
799 bool res = true;
800 for (;;) {
801 errno = 0;
802 auto const entry = readdir(dirp.get());
803 if (!entry) {
804 if (errno) {
805 PLOG(ERROR) << "Unable to read directory: " + directory_path;
806 return false;
807 }
808 break;
809 }
810 if (entry->d_type != DT_DIR || entry->d_name[0] == '.') {
811 LOG(DEBUG) << "Skipping non-user " << entry->d_name;
812 continue;
813 }
814 res &= destroy_volkey(directory_path + "/" + entry->d_name, volume_uuid);
815 }
816 return res;
817}
818
819bool e4crypt_destroy_volume_keys(const std::string& volume_uuid) {
820 bool res = true;
821 LOG(DEBUG) << "e4crypt_destroy_volume_keys for volume " << escape_empty(volume_uuid);
Paul Crowley26a53882017-10-26 11:16:39 -0700822 auto secdiscardable_path = volume_secdiscardable_path(volume_uuid);
823 res &= android::vold::runSecdiscardSingle(secdiscardable_path);
Paul Crowleyc6433a22017-10-24 14:54:43 -0700824 res &= destroy_volume_keys("/data/misc_ce", volume_uuid);
825 res &= destroy_volume_keys("/data/misc_de", volume_uuid);
826 return res;
827}
828
Paul Crowley3b71fc52017-10-09 10:55:21 -0700829bool e4crypt_secdiscard(const std::string& path) {
830 return android::vold::runSecdiscardSingle(path);
Rubin Xu2436e272017-04-27 20:43:10 +0100831}