blob: a2049a2a012b0770735d4a04234e6ad5c338ca5e [file] [log] [blame]
bigbiff7ba75002020-04-11 20:47:09 -04001/*
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
17#include "FsCrypt.h"
18
19#include "KeyStorage.h"
20#include "KeyUtil.h"
21#include "Utils.h"
bigbiffa957f072021-03-07 18:20:29 -050022#include "VoldUtil.h"
bigbiff7ba75002020-04-11 20:47:09 -040023
24#include <algorithm>
25#include <map>
bigbiffa957f072021-03-07 18:20:29 -050026#include <optional>
bigbiff7ba75002020-04-11 20:47:09 -040027#include <set>
28#include <sstream>
29#include <string>
30#include <vector>
31
32#include <dirent.h>
33#include <errno.h>
34#include <fcntl.h>
35#include <limits.h>
36#include <selinux/android.h>
37#include <sys/mount.h>
38#include <sys/stat.h>
39#include <sys/types.h>
40#include <unistd.h>
41
42#include <private/android_filesystem_config.h>
bigbiffa957f072021-03-07 18:20:29 -050043#include <private/android_projectid_config.h>
bigbiff7ba75002020-04-11 20:47:09 -040044
bigbiffa957f072021-03-07 18:20:29 -050045#include "android/os/IVold.h"
bigbiff7ba75002020-04-11 20:47:09 -040046
47#define EMULATED_USES_SELINUX 0
48#define MANAGE_MISC_DIRS 0
49
50#include <cutils/fs.h>
51#include <cutils/properties.h>
52
53#include <fscrypt/fscrypt.h>
bigbiff7ba75002020-04-11 20:47:09 -040054#include <keyutils.h>
bigbiffa957f072021-03-07 18:20:29 -050055#include <libdm/dm.h>
bigbiff7ba75002020-04-11 20:47:09 -040056
57#include <android-base/file.h>
58#include <android-base/logging.h>
59#include <android-base/properties.h>
60#include <android-base/stringprintf.h>
bigbiffa957f072021-03-07 18:20:29 -050061#include <android-base/strings.h>
bigbiff7ba75002020-04-11 20:47:09 -040062#include <android-base/unique_fd.h>
63
bigbiffa957f072021-03-07 18:20:29 -050064#include "fscrypt-common.h"
bigbiff7ba75002020-04-11 20:47:09 -040065
bigbiffa957f072021-03-07 18:20:29 -050066using android::base::Basename;
67using android::base::Realpath;
68using android::base::StartsWith;
bigbiff7ba75002020-04-11 20:47:09 -040069using android::base::StringPrintf;
70using android::fs_mgr::GetEntryForMountPoint;
bigbiffa957f072021-03-07 18:20:29 -050071using ::BuildDataPath;
72using ::IsFilesystemSupported;
73using ::kEmptyAuthentication;
74using ::KeyBuffer;
75using ::KeyGeneration;
76using ::retrieveKey;
77using ::retrieveOrGenerateKey;
78using ::SetQuotaInherit;
79using ::SetQuotaProjectId;
80using ::writeStringToFile;
81using namespace android::fscrypt;
82using namespace android::dm;
bigbiff7ba75002020-04-11 20:47:09 -040083
bigbiffa957f072021-03-07 18:20:29 -050084// Map user ids to encryption policies
85std::map<userid_t, EncryptionPolicy> s_de_policies;
86std::map<userid_t, EncryptionPolicy> s_ce_policies;
87std::string de_key_raw_ref;
bigbiff7ba75002020-04-11 20:47:09 -040088
89namespace {
90
bigbiff7ba75002020-04-11 20:47:09 -040091const std::string device_key_dir = std::string() + DATA_MNT_POINT + fscrypt_unencrypted_folder;
92const std::string device_key_path = device_key_dir + "/key";
93const std::string device_key_temp = device_key_dir + "/temp";
94
95const std::string user_key_dir = std::string() + DATA_MNT_POINT + "/misc/vold/user_keys";
96const std::string user_key_temp = user_key_dir + "/temp";
bigbiffad58e1b2020-07-06 20:24:34 -040097const std::string prepare_subdirs_path = "/system/bin/vold_prepare_subdirs";
bigbiff7ba75002020-04-11 20:47:09 -040098
99const std::string systemwide_volume_key_dir =
100 std::string() + DATA_MNT_POINT + "/misc/vold/volume_keys";
bigbiff7ba75002020-04-11 20:47:09 -0400101
102// Some users are ephemeral, don't try to wipe their keys from disk
103std::set<userid_t> s_ephemeral_users;
104
bigbiff7ba75002020-04-11 20:47:09 -0400105} // namespace
106
bigbiffa957f072021-03-07 18:20:29 -0500107// Returns KeyGeneration suitable for key as described in EncryptionOptions
108static KeyGeneration makeGen(const EncryptionOptions& options) {
109 return KeyGeneration{FSCRYPT_MAX_KEY_SIZE, true, options.use_hw_wrapped_key};
110}
111
bigbiff7ba75002020-04-11 20:47:09 -0400112static bool fscrypt_is_emulated() {
113 return property_get_bool("persist.sys.emulate_fbe", false);
114}
115
116static const char* escape_empty(const std::string& value) {
117 return value.empty() ? "null" : value.c_str();
118}
119
120static std::string get_de_key_path(userid_t user_id) {
121 return StringPrintf("%s/de/%d", user_key_dir.c_str(), user_id);
122}
123
124static std::string get_ce_key_directory_path(userid_t user_id) {
125 return StringPrintf("%s/ce/%d", user_key_dir.c_str(), user_id);
126}
127
128// Returns the keys newest first
129static std::vector<std::string> get_ce_key_paths(const std::string& directory_path) {
130 auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(directory_path.c_str()), closedir);
131 if (!dirp) {
132 PLOG(ERROR) << "Unable to open ce key directory: " + directory_path;
133 return std::vector<std::string>();
134 }
135 std::vector<std::string> result;
136 for (;;) {
137 errno = 0;
138 auto const entry = readdir(dirp.get());
139 if (!entry) {
140 if (errno) {
141 PLOG(ERROR) << "Unable to read ce key directory: " + directory_path;
142 return std::vector<std::string>();
143 }
144 break;
145 }
146 if (entry->d_type != DT_DIR || entry->d_name[0] != 'c') {
bigbiffa957f072021-03-07 18:20:29 -0500147 LOG(INFO) << "Skipping non-key " << entry->d_name;
bigbiff7ba75002020-04-11 20:47:09 -0400148 continue;
149 }
150 result.emplace_back(directory_path + "/" + entry->d_name);
151 }
152 std::sort(result.begin(), result.end());
153 std::reverse(result.begin(), result.end());
154 return result;
155}
156
157static std::string get_ce_key_current_path(const std::string& directory_path) {
158 return directory_path + "/current";
159}
160
161static bool get_ce_key_new_path(const std::string& directory_path,
162 const std::vector<std::string>& paths, std::string* ce_key_path) {
163 if (paths.empty()) {
164 *ce_key_path = get_ce_key_current_path(directory_path);
165 return true;
166 }
167 for (unsigned int i = 0; i < UINT_MAX; i++) {
168 auto const candidate = StringPrintf("%s/cx%010u", directory_path.c_str(), i);
169 if (paths[0] < candidate) {
170 *ce_key_path = candidate;
171 return true;
172 }
173 }
174 return false;
175}
176
177// Discard all keys but the named one; rename it to canonical name.
178// No point in acting on errors in this; ignore them.
179static void fixate_user_ce_key(const std::string& directory_path, const std::string& to_fix,
180 const std::vector<std::string>& paths) {
181 for (auto const other_path : paths) {
182 if (other_path != to_fix) {
bigbiffa957f072021-03-07 18:20:29 -0500183 ::destroyKey(other_path);
bigbiff7ba75002020-04-11 20:47:09 -0400184 }
185 }
186 auto const current_path = get_ce_key_current_path(directory_path);
187 if (to_fix != current_path) {
bigbiffa957f072021-03-07 18:20:29 -0500188 LOG(INFO) << "Renaming " << to_fix << " to " << current_path;
bigbiff7ba75002020-04-11 20:47:09 -0400189 if (rename(to_fix.c_str(), current_path.c_str()) != 0) {
190 PLOG(WARNING) << "Unable to rename " << to_fix << " to " << current_path;
191 return;
192 }
193 }
bigbiffa957f072021-03-07 18:20:29 -0500194 ::FsyncDirectory(directory_path);
bigbiff7ba75002020-04-11 20:47:09 -0400195}
196
197static bool read_and_fixate_user_ce_key(userid_t user_id,
bigbiffa957f072021-03-07 18:20:29 -0500198 const ::KeyAuthentication& auth,
bigbiff7ba75002020-04-11 20:47:09 -0400199 KeyBuffer* ce_key) {
200 auto const directory_path = get_ce_key_directory_path(user_id);
201 auto const paths = get_ce_key_paths(directory_path);
202 for (auto const ce_key_path : paths) {
bigbiffa957f072021-03-07 18:20:29 -0500203 LOG(INFO) << "Trying user CE key " << ce_key_path;
bigbiffbbbfe172021-05-30 15:52:41 -0400204 if (retrieveKey(ce_key_path, auth, ce_key, true)) {
bigbiffa957f072021-03-07 18:20:29 -0500205 LOG(INFO) << "Successfully retrieved key";
bigbiff7ba75002020-04-11 20:47:09 -0400206 fixate_user_ce_key(directory_path, ce_key_path, paths);
207 return true;
208 }
209 }
210 LOG(ERROR) << "Failed to find working ce key for user " << user_id;
211 return false;
212}
213
bigbiffa957f072021-03-07 18:20:29 -0500214static bool IsEmmcStorage(const std::string& blk_device) {
215 // Handle symlinks.
216 std::string real_path;
217 if (!Realpath(blk_device, &real_path)) {
218 real_path = blk_device;
219 }
220
221 // Handle logical volumes.
222 auto& dm = DeviceMapper::Instance();
223 for (;;) {
224 auto parent = dm.GetParentBlockDeviceByPath(real_path);
225 if (!parent.has_value()) break;
226 real_path = *parent;
227 }
228
229 // Now we should have the "real" block device.
230 LOG(INFO) << "IsEmmcStorage(): blk_device = " << blk_device << ", real_path=" << real_path;
231 return StartsWith(Basename(real_path), "mmcblk");
232}
233
234// Retrieve the options to use for encryption policies on the /data filesystem.
235static bool get_data_file_encryption_options(EncryptionOptions* options) {
bigbiff543a9282021-10-02 09:50:58 -0400236 if (fstab_default.empty()) {
237 if (!ReadDefaultFstab(&fstab_default)) {
238 PLOG(ERROR) << "Failed to open default fstab";
239 return false;
240 }
mauronofrio matarrese79820322020-05-25 19:48:56 +0200241 }
bigbiffa957f072021-03-07 18:20:29 -0500242 auto entry = GetEntryForMountPoint(&fstab_default, DATA_MNT_POINT);
243 if (entry == nullptr) {
244 LOG(ERROR) << "No mount point entry for " << DATA_MNT_POINT;
mauronofrio matarresef1079ed2020-05-25 20:52:57 +0200245 return false;
246 }
bigbiffa957f072021-03-07 18:20:29 -0500247 if (!ParseOptions(entry->encryption_options, options)) {
248 LOG(ERROR) << "Unable to parse encryption options for " << DATA_MNT_POINT ": "
249 << entry->encryption_options;
250 return false;
251 }
bigbiffbcd23d32021-09-22 18:22:13 -0400252 if (options->version == 1) {
253 options->use_hw_wrapped_key =
254 GetEntryForMountPoint(&fstab_default, DATA_MNT_POINT)->fs_mgr_flags.wrapped_key;
255 }
bigbiffa957f072021-03-07 18:20:29 -0500256 if ((options->flags & FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32) &&
257 !IsEmmcStorage(entry->blk_device)) {
258 LOG(ERROR) << "The emmc_optimized encryption flag is only allowed on eMMC storage. Remove "
259 "this flag from the device's fstab";
260 return false;
261 }
262 return true;
mauronofrio matarresef1079ed2020-05-25 20:52:57 +0200263}
264
bigbiffa957f072021-03-07 18:20:29 -0500265static bool install_storage_key(const std::string& mountpoint, const EncryptionOptions& options,
266 const KeyBuffer& key, EncryptionPolicy* policy) {
267 KeyBuffer ephemeral_wrapped_key;
268 if (options.use_hw_wrapped_key) {
269 if (!exportWrappedStorageKey(key, &ephemeral_wrapped_key)) {
270 LOG(ERROR) << "Failed to get ephemeral wrapped key";
271 return false;
272 }
273 }
274 return installKey(mountpoint, options, options.use_hw_wrapped_key ? ephemeral_wrapped_key : key,
275 policy);
276}
277
278// Retrieve the options to use for encryption policies on adoptable storage.
279static bool get_volume_file_encryption_options(EncryptionOptions* options) {
280 // If we give the empty string, libfscrypt will use the default (currently XTS)
281 auto contents_mode = android::base::GetProperty("ro.crypto.volume.contents_mode", "");
282 // HEH as default was always a mistake. Use the libfscrypt default (CTS)
283 // for devices launching on versions above Android 10.
284 auto first_api_level = GetFirstApiLevel();
285 constexpr uint64_t pre_gki_level = 29;
286 auto filenames_mode =
287 android::base::GetProperty("ro.crypto.volume.filenames_mode",
288 first_api_level > pre_gki_level ? "" : "aes-256-heh");
289 auto options_string = android::base::GetProperty("ro.crypto.volume.options",
290 contents_mode + ":" + filenames_mode);
291 if (!ParseOptionsForApiLevel(first_api_level, options_string, options)) {
292 LOG(ERROR) << "Unable to parse volume encryption options: " << options_string;
293 return false;
294 }
295 if (options->flags & FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32) {
296 LOG(ERROR) << "The emmc_optimized encryption flag is only allowed on eMMC storage. Remove "
297 "this flag from ro.crypto.volume.options";
298 return false;
299 }
300 return true;
mauronofrio539597d2020-05-25 22:23:48 +0200301}
302
bigbiffbcd23d32021-09-22 18:22:13 -0400303bool is_metadata_wrapped_key_supported() {
bigbiff543a9282021-10-02 09:50:58 -0400304 if (fstab_default.empty()) {
305 if (!ReadDefaultFstab(&fstab_default)) {
306 PLOG(ERROR) << "Failed to open default fstab";
307 return false;
308 }
bigbiffbcd23d32021-09-22 18:22:13 -0400309 }
310 return GetEntryForMountPoint(&fstab_default, METADATA_MNT_POINT)->fs_mgr_flags.wrapped_key;
311}
312
bigbiff7ba75002020-04-11 20:47:09 -0400313static bool read_and_install_user_ce_key(userid_t user_id,
bigbiffa957f072021-03-07 18:20:29 -0500314 const ::KeyAuthentication& auth) {
315 if (s_ce_policies.count(user_id) != 0) return true;
316 EncryptionOptions options;
317 if (!get_data_file_encryption_options(&options)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400318 KeyBuffer ce_key;
319 if (!read_and_fixate_user_ce_key(user_id, auth, &ce_key)) return false;
bigbiffa957f072021-03-07 18:20:29 -0500320 EncryptionPolicy ce_policy;
321 if (!install_storage_key(DATA_MNT_POINT, options, ce_key, &ce_policy)) return false;
322 s_ce_policies[user_id] = ce_policy;
323 LOG(INFO) << "Installed ce key for user " << user_id;
bigbiff7ba75002020-04-11 20:47:09 -0400324 return true;
325}
326
327static bool prepare_dir(const std::string& dir, mode_t mode, uid_t uid, gid_t gid) {
bigbiffa957f072021-03-07 18:20:29 -0500328 LOG(INFO) << "Preparing: " << dir;
bigbiff7ba75002020-04-11 20:47:09 -0400329 if (fs_prepare_dir(dir.c_str(), mode, uid, gid) != 0) {
330 PLOG(ERROR) << "Failed to prepare " << dir;
331 return false;
332 }
333 return true;
334}
335
336static bool destroy_dir(const std::string& dir) {
bigbiffa957f072021-03-07 18:20:29 -0500337 LOG(INFO) << "Destroying: " << dir;
bigbiff7ba75002020-04-11 20:47:09 -0400338 if (rmdir(dir.c_str()) != 0 && errno != ENOENT) {
339 PLOG(ERROR) << "Failed to destroy " << dir;
340 return false;
341 }
342 return true;
343}
344
345// NB this assumes that there is only one thread listening for crypt commands, because
346// it creates keys in a fixed location.
347static bool create_and_install_user_keys(userid_t user_id, bool create_ephemeral) {
bigbiffa957f072021-03-07 18:20:29 -0500348 LOG(INFO) << "fscrypt::create_and_install_user_keys";
349 EncryptionOptions options;
350 if (!get_data_file_encryption_options(&options)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400351 KeyBuffer de_key, ce_key;
bigbiffa957f072021-03-07 18:20:29 -0500352 if (!generateStorageKey(makeGen(options), &de_key)) return false;
353 if (!generateStorageKey(makeGen(options), &ce_key)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400354 if (create_ephemeral) {
355 // If the key should be created as ephemeral, don't store it.
356 s_ephemeral_users.insert(user_id);
357 } else {
358 auto const directory_path = get_ce_key_directory_path(user_id);
359 if (!prepare_dir(directory_path, 0700, AID_ROOT, AID_ROOT)) return false;
360 auto const paths = get_ce_key_paths(directory_path);
361 std::string ce_key_path;
362 if (!get_ce_key_new_path(directory_path, paths, &ce_key_path)) return false;
bigbiffa957f072021-03-07 18:20:29 -0500363 if (!::storeKeyAtomically(ce_key_path, user_key_temp, kEmptyAuthentication,
bigbiff7ba75002020-04-11 20:47:09 -0400364 ce_key))
365 return false;
366 fixate_user_ce_key(directory_path, ce_key_path, paths);
367 // Write DE key second; once this is written, all is good.
bigbiffa957f072021-03-07 18:20:29 -0500368 if (!::storeKeyAtomically(get_de_key_path(user_id), user_key_temp,
bigbiff7ba75002020-04-11 20:47:09 -0400369 kEmptyAuthentication, de_key))
370 return false;
371 }
bigbiffa957f072021-03-07 18:20:29 -0500372 EncryptionPolicy de_policy;
373 if (!install_storage_key(DATA_MNT_POINT, options, de_key, &de_policy)) return false;
374 s_de_policies[user_id] = de_policy;
375 LOG(INFO) << "fscrypt::added de_policy";
376 EncryptionPolicy ce_policy;
377 if (!install_storage_key(DATA_MNT_POINT, options, ce_key, &ce_policy)) return false;
378 s_ce_policies[user_id] = ce_policy;
379 LOG(INFO) << "Created keys for user " << user_id;
bigbiff7ba75002020-04-11 20:47:09 -0400380 return true;
381}
382
bigbiffa957f072021-03-07 18:20:29 -0500383bool lookup_policy(const std::map<userid_t, EncryptionPolicy>& key_map, userid_t user_id,
384 EncryptionPolicy* policy) {
bigbiff7ba75002020-04-11 20:47:09 -0400385 auto refi = key_map.find(user_id);
386 if (refi == key_map.end()) {
bigbiffa957f072021-03-07 18:20:29 -0500387 LOG(ERROR) << "Cannot find key for " << user_id;
bigbiff7ba75002020-04-11 20:47:09 -0400388 return false;
389 }
bigbiffa957f072021-03-07 18:20:29 -0500390 *policy = refi->second;
bigbiff7ba75002020-04-11 20:47:09 -0400391 return true;
392}
393
bigbiff7ba75002020-04-11 20:47:09 -0400394static bool is_numeric(const char* name) {
395 for (const char* p = name; *p != '\0'; p++) {
396 if (!isdigit(*p)) return false;
397 }
398 return true;
399}
400
401static bool load_all_de_keys() {
bigbiffa957f072021-03-07 18:20:29 -0500402 LOG(INFO) << "fscrypt::load_all_de_keys";
403 EncryptionOptions options;
404 if (!get_data_file_encryption_options(&options)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400405 auto de_dir = user_key_dir + "/de";
406 auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(de_dir.c_str()), closedir);
407 if (!dirp) {
408 PLOG(ERROR) << "Unable to read de key directory";
409 return false;
410 }
411 for (;;) {
412 errno = 0;
413 auto entry = readdir(dirp.get());
414 if (!entry) {
415 if (errno) {
416 PLOG(ERROR) << "Unable to read de key directory";
417 return false;
418 }
419 break;
420 }
421 if (entry->d_type != DT_DIR || !is_numeric(entry->d_name)) {
bigbiffa957f072021-03-07 18:20:29 -0500422 LOG(INFO) << "Skipping non-de-key " << entry->d_name;
bigbiff7ba75002020-04-11 20:47:09 -0400423 continue;
424 }
425 userid_t user_id = std::stoi(entry->d_name);
bigbiffa957f072021-03-07 18:20:29 -0500426 auto key_path = de_dir + "/" + entry->d_name;
427 KeyBuffer de_key;
bigbiffbbbfe172021-05-30 15:52:41 -0400428 if (!retrieveKey(key_path, kEmptyAuthentication, &de_key, true)) return false;
bigbiffa957f072021-03-07 18:20:29 -0500429 EncryptionPolicy de_policy;
430 if (!install_storage_key(DATA_MNT_POINT, options, de_key, &de_policy)) return false;
431 auto ret = s_de_policies.insert({user_id, de_policy});
432 LOG(INFO) << "fscrypt::load_all_de_keys::s_de_policies::size::" << s_de_policies.size();
433 if (!ret.second && ret.first->second != de_policy) {
434 LOG(INFO) << "DE policy for user" << user_id << " changed";
435 return false;
bigbiff7ba75002020-04-11 20:47:09 -0400436 }
bigbiffa957f072021-03-07 18:20:29 -0500437 LOG(INFO) << "Installed de key for user " << user_id;
438 std::string user_prop = "twrp.user." + std::to_string(user_id) + ".decrypt";
439 property_set(user_prop.c_str(), "0");
bigbiff7ba75002020-04-11 20:47:09 -0400440 }
441 // fscrypt:TODO: go through all DE directories, ensure that all user dirs have the
442 // correct policy set on them, and that no rogue ones exist.
443 return true;
444}
445
bigbiffa957f072021-03-07 18:20:29 -0500446// Attempt to reinstall CE keys for users that we think are unlocked.
447static bool try_reload_ce_keys() {
448 for (const auto& it : s_ce_policies) {
449 if (!::reloadKeyFromSessionKeyring(DATA_MNT_POINT, it.second)) {
450 LOG(ERROR) << "Failed to load CE key from session keyring for user " << it.first;
451 return false;
452 }
453 }
454 return true;
455}
456
bigbiff7ba75002020-04-11 20:47:09 -0400457bool fscrypt_initialize_systemwide_keys() {
458 LOG(INFO) << "fscrypt_initialize_systemwide_keys";
459
bigbiffa957f072021-03-07 18:20:29 -0500460 EncryptionOptions options;
461 if (!get_data_file_encryption_options(&options)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400462
bigbiffa957f072021-03-07 18:20:29 -0500463 KeyBuffer device_key;
464 if (!retrieveOrGenerateKey(device_key_path, device_key_temp, kEmptyAuthentication,
465 makeGen(options), &device_key))
bigbiff7ba75002020-04-11 20:47:09 -0400466 return false;
bigbiff7ba75002020-04-11 20:47:09 -0400467
bigbiffa957f072021-03-07 18:20:29 -0500468 EncryptionPolicy device_policy;
469 if (!install_storage_key(DATA_MNT_POINT, options, device_key, &device_policy)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400470
bigbiffa957f072021-03-07 18:20:29 -0500471 std::string options_string;
472 if (!OptionsToString(device_policy.options, &options_string)) {
473 LOG(ERROR) << "Unable to serialize options";
474 return false;
475 }
476 std::string options_filename = std::string(DATA_MNT_POINT) + fscrypt_key_mode;
477 if (!::writeStringToFile(options_string, options_filename)) return false;
478
479 std::string ref_filename = std::string(DATA_MNT_POINT) + fscrypt_key_ref;
480 de_key_raw_ref = device_policy.key_raw_ref;
481 if (!::writeStringToFile(device_policy.key_raw_ref, ref_filename)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400482 LOG(INFO) << "Wrote system DE key reference to:" << ref_filename;
483
484 KeyBuffer per_boot_key;
bigbiffa957f072021-03-07 18:20:29 -0500485 if (!generateStorageKey(makeGen(options), &per_boot_key)) return false;
486 EncryptionPolicy per_boot_policy;
487 if (!install_storage_key(DATA_MNT_POINT, options, per_boot_key, &per_boot_policy)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400488 std::string per_boot_ref_filename = std::string("/data") + fscrypt_key_per_boot_ref;
bigbiffa957f072021-03-07 18:20:29 -0500489 if (!::writeStringToFile(per_boot_policy.key_raw_ref, per_boot_ref_filename))
490 return false;
bigbiff7ba75002020-04-11 20:47:09 -0400491 LOG(INFO) << "Wrote per boot key reference to:" << per_boot_ref_filename;
492
bigbiffa957f072021-03-07 18:20:29 -0500493 if (!::FsyncDirectory(device_key_dir)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400494 return true;
495}
496
497bool fscrypt_init_user0() {
bigbiff543a9282021-10-02 09:50:58 -0400498 if (fstab_default.empty()) {
499 if (!ReadDefaultFstab(&fstab_default)) {
500 PLOG(ERROR) << "Failed to open default fstab";
501 return -1;
502 }
bigbiff7ba75002020-04-11 20:47:09 -0400503 }
bigbiffa957f072021-03-07 18:20:29 -0500504 LOG(INFO) << "fscrypt_init_user0";
bigbiff7ba75002020-04-11 20:47:09 -0400505 if (fscrypt_is_native()) {
506 if (!prepare_dir(user_key_dir, 0700, AID_ROOT, AID_ROOT)) return false;
507 if (!prepare_dir(user_key_dir + "/ce", 0700, AID_ROOT, AID_ROOT)) return false;
508 if (!prepare_dir(user_key_dir + "/de", 0700, AID_ROOT, AID_ROOT)) return false;
bigbiffa957f072021-03-07 18:20:29 -0500509 if (!::pathExists(get_de_key_path(0))) {
bigbiff7ba75002020-04-11 20:47:09 -0400510 if (!create_and_install_user_keys(0, false)) return false;
511 }
512 // TODO: switch to loading only DE_0 here once framework makes
513 // explicit calls to install DE keys for secondary users
514 if (!load_all_de_keys()) return false;
515 }
516 // We can only safely prepare DE storage here, since CE keys are probably
517 // entangled with user credentials. The framework will always prepare CE
518 // storage once CE keys are installed.
bigbiffa957f072021-03-07 18:20:29 -0500519 LOG(INFO) << "attempting fscrypt_prepare_user_storage";
520 if (!fscrypt_prepare_user_storage("", 0, 0, android::os::IVold::STORAGE_FLAG_DE)) {
bigbiff7ba75002020-04-11 20:47:09 -0400521 LOG(ERROR) << "Failed to prepare user 0 storage";
522 return false;
523 }
bigbiffa957f072021-03-07 18:20:29 -0500524
bigbiff7ba75002020-04-11 20:47:09 -0400525 // If this is a non-FBE device that recently left an emulated mode,
526 // restore user data directories to known-good state.
527 if (!fscrypt_is_native() && !fscrypt_is_emulated()) {
bigbiffa957f072021-03-07 18:20:29 -0500528 LOG(INFO) << "unlocking data media";
bigbiff7ba75002020-04-11 20:47:09 -0400529 fscrypt_unlock_user_key(0, 0, "!", "!");
530 }
531
bigbiffa957f072021-03-07 18:20:29 -0500532 // In some scenarios (e.g. userspace reboot) we might unmount userdata
533 // without doing a hard reboot. If CE keys were stored in fs keyring then
534 // they will be lost after unmount. Attempt to re-install them.
535 if (fscrypt_is_native() && ::isFsKeyringSupported()) {
536 LOG(INFO) << "reloading ce keys";
537 if (!try_reload_ce_keys()) return false;
538 }
539
bigbiff7ba75002020-04-11 20:47:09 -0400540 return true;
541}
542
543bool fscrypt_vold_create_user_key(userid_t user_id, int serial, bool ephemeral) {
bigbiffa957f072021-03-07 18:20:29 -0500544 LOG(INFO) << "fscrypt_vold_create_user_key for " << user_id << " serial " << serial;
bigbiff7ba75002020-04-11 20:47:09 -0400545 if (!fscrypt_is_native()) {
bigbiffa957f072021-03-07 18:20:29 -0500546 return true;
bigbiff7ba75002020-04-11 20:47:09 -0400547 }
548 // FIXME test for existence of key that is not loaded yet
bigbiffa957f072021-03-07 18:20:29 -0500549 if (s_ce_policies.count(user_id) != 0) {
bigbiff7ba75002020-04-11 20:47:09 -0400550 LOG(ERROR) << "Already exists, can't fscrypt_vold_create_user_key for " << user_id
551 << " serial " << serial;
552 // FIXME should we fail the command?
553 return true;
554 }
555 if (!create_and_install_user_keys(user_id, ephemeral)) {
556 return false;
557 }
558 return true;
559}
560
bigbiffa957f072021-03-07 18:20:29 -0500561// "Lock" all encrypted directories whose key has been removed. This is needed
562// in the case where the keys are being put in the session keyring (rather in
563// the newer filesystem-level keyrings), because removing a key from the session
564// keyring doesn't affect inodes in the kernel's inode cache whose per-file key
565// was already set up. So to remove the per-file keys and make the files
566// "appear encrypted", these inodes must be evicted.
567//
568// To do this, sync() to clean all dirty inodes, then drop all reclaimable slab
569// objects systemwide. This is overkill, but it's the best available method
570// currently. Don't use drop_caches mode "3" because that also evicts pagecache
571// for in-use files; all files relevant here are already closed and sync'ed.
572static void drop_caches_if_needed() {
573 if (::isFsKeyringSupported()) {
574 return;
575 }
bigbiff7ba75002020-04-11 20:47:09 -0400576 sync();
bigbiffa957f072021-03-07 18:20:29 -0500577 if (!writeStringToFile("2", "/proc/sys/vm/drop_caches")) {
bigbiff7ba75002020-04-11 20:47:09 -0400578 PLOG(ERROR) << "Failed to drop caches during key eviction";
579 }
580}
581
582static bool evict_ce_key(userid_t user_id) {
bigbiff7ba75002020-04-11 20:47:09 -0400583 bool success = true;
bigbiffa957f072021-03-07 18:20:29 -0500584 EncryptionPolicy policy;
bigbiff7ba75002020-04-11 20:47:09 -0400585 // If we haven't loaded the CE key, no need to evict it.
bigbiffa957f072021-03-07 18:20:29 -0500586 if (lookup_policy(s_ce_policies, user_id, &policy)) {
587 success &= ::evictKey(DATA_MNT_POINT, policy);
588 drop_caches_if_needed();
bigbiff7ba75002020-04-11 20:47:09 -0400589 }
bigbiffa957f072021-03-07 18:20:29 -0500590 s_ce_policies.erase(user_id);
bigbiff7ba75002020-04-11 20:47:09 -0400591 return success;
592}
593
594bool fscrypt_destroy_user_key(userid_t user_id) {
bigbiffa957f072021-03-07 18:20:29 -0500595 LOG(INFO) << "fscrypt_destroy_user_key(" << user_id << ")";
bigbiff7ba75002020-04-11 20:47:09 -0400596 if (!fscrypt_is_native()) {
597 return true;
598 }
599 bool success = true;
bigbiff7ba75002020-04-11 20:47:09 -0400600 success &= evict_ce_key(user_id);
bigbiffa957f072021-03-07 18:20:29 -0500601 EncryptionPolicy de_policy;
602 success &= lookup_policy(s_de_policies, user_id, &de_policy) &&
603 ::evictKey(DATA_MNT_POINT, de_policy);
604 s_de_policies.erase(user_id);
bigbiff7ba75002020-04-11 20:47:09 -0400605 auto it = s_ephemeral_users.find(user_id);
606 if (it != s_ephemeral_users.end()) {
607 s_ephemeral_users.erase(it);
608 } else {
609 for (auto const path : get_ce_key_paths(get_ce_key_directory_path(user_id))) {
bigbiffa957f072021-03-07 18:20:29 -0500610 success &= ::destroyKey(path);
bigbiff7ba75002020-04-11 20:47:09 -0400611 }
612 auto de_key_path = get_de_key_path(user_id);
bigbiffa957f072021-03-07 18:20:29 -0500613 if (::pathExists(de_key_path)) {
614 success &= ::destroyKey(de_key_path);
bigbiff7ba75002020-04-11 20:47:09 -0400615 } else {
616 LOG(INFO) << "Not present so not erasing: " << de_key_path;
617 }
618 }
619 return success;
620}
621
622static bool emulated_lock(const std::string& path) {
623 if (chmod(path.c_str(), 0000) != 0) {
624 PLOG(ERROR) << "Failed to chmod " << path;
625 return false;
626 }
627#if EMULATED_USES_SELINUX
628 if (setfilecon(path.c_str(), "u:object_r:storage_stub_file:s0") != 0) {
629 PLOG(WARNING) << "Failed to setfilecon " << path;
630 return false;
631 }
632#endif
633 return true;
634}
635
636static bool emulated_unlock(const std::string& path, mode_t mode) {
637 if (chmod(path.c_str(), mode) != 0) {
638 PLOG(ERROR) << "Failed to chmod " << path;
639 // FIXME temporary workaround for b/26713622
640 if (fscrypt_is_emulated()) return false;
641 }
642#if EMULATED_USES_SELINUX
643 if (selinux_android_restorecon(path.c_str(), SELINUX_ANDROID_RESTORECON_FORCE) != 0) {
644 PLOG(WARNING) << "Failed to restorecon " << path;
645 // FIXME temporary workaround for b/26713622
646 if (fscrypt_is_emulated()) return false;
647 }
648#endif
649 return true;
650}
651
652static bool parse_hex(const std::string& hex, std::string* result) {
653 if (hex == "!") {
654 *result = "";
655 return true;
656 }
bigbiffa957f072021-03-07 18:20:29 -0500657 if (::HexToStr(hex, *result) != 0) {
bigbiff7ba75002020-04-11 20:47:09 -0400658 LOG(ERROR) << "Invalid FBE hex string"; // Don't log the string for security reasons
659 return false;
660 }
661 return true;
662}
663
bigbiffa957f072021-03-07 18:20:29 -0500664static std::optional<::KeyAuthentication> authentication_from_hex(
665 const std::string& token_hex, const std::string& secret_hex) {
666 std::string token, secret;
667 if (!parse_hex(token_hex, &token)) return std::optional<::KeyAuthentication>();
668 if (!parse_hex(secret_hex, &secret)) return std::optional<::KeyAuthentication>();
669 if (secret.empty()) {
670 return kEmptyAuthentication;
671 } else {
672 return ::KeyAuthentication(token, secret);
673 }
674}
675
bigbiff7ba75002020-04-11 20:47:09 -0400676static std::string volkey_path(const std::string& misc_path, const std::string& volume_uuid) {
677 return misc_path + "/vold/volume_keys/" + volume_uuid + "/default";
678}
679
680static std::string volume_secdiscardable_path(const std::string& volume_uuid) {
681 return systemwide_volume_key_dir + "/" + volume_uuid + "/secdiscardable";
682}
683
684static bool read_or_create_volkey(const std::string& misc_path, const std::string& volume_uuid,
bigbiffa957f072021-03-07 18:20:29 -0500685 EncryptionPolicy* policy) {
bigbiff7ba75002020-04-11 20:47:09 -0400686 auto secdiscardable_path = volume_secdiscardable_path(volume_uuid);
687 std::string secdiscardable_hash;
bigbiffa957f072021-03-07 18:20:29 -0500688 if (::pathExists(secdiscardable_path)) {
689 if (!readSecdiscardable(secdiscardable_path, &secdiscardable_hash))
bigbiff7ba75002020-04-11 20:47:09 -0400690 return false;
691 } else {
692 if (fs_mkdirs(secdiscardable_path.c_str(), 0700) != 0) {
693 PLOG(ERROR) << "Creating directories for: " << secdiscardable_path;
694 return false;
695 }
bigbiffa957f072021-03-07 18:20:29 -0500696 if (!::createSecdiscardable(secdiscardable_path, &secdiscardable_hash))
bigbiff7ba75002020-04-11 20:47:09 -0400697 return false;
698 }
699 auto key_path = volkey_path(misc_path, volume_uuid);
700 if (fs_mkdirs(key_path.c_str(), 0700) != 0) {
701 PLOG(ERROR) << "Creating directories for: " << key_path;
702 return false;
703 }
bigbiffa957f072021-03-07 18:20:29 -0500704 ::KeyAuthentication auth("", secdiscardable_hash);
mauronofrio matarrese79820322020-05-25 19:48:56 +0200705
bigbiffa957f072021-03-07 18:20:29 -0500706 EncryptionOptions options;
707 if (!get_volume_file_encryption_options(&options)) return false;
708 KeyBuffer key;
709 if (!retrieveOrGenerateKey(key_path, key_path + "_tmp", auth, makeGen(options), &key))
bigbiff7ba75002020-04-11 20:47:09 -0400710 return false;
bigbiffa957f072021-03-07 18:20:29 -0500711 if (!install_storage_key(BuildDataPath(volume_uuid), options, key, policy)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400712 return true;
713}
714
715static bool destroy_volkey(const std::string& misc_path, const std::string& volume_uuid) {
716 auto path = volkey_path(misc_path, volume_uuid);
bigbiffa957f072021-03-07 18:20:29 -0500717 if (!::pathExists(path)) return true;
718 return ::destroyKey(path);
719}
720
721static bool fscrypt_rewrap_user_key(userid_t user_id, int serial,
722 const ::KeyAuthentication& retrieve_auth,
723 const ::KeyAuthentication& store_auth) {
724 if (s_ephemeral_users.count(user_id) != 0) return true;
725 auto const directory_path = get_ce_key_directory_path(user_id);
726 KeyBuffer ce_key;
727 std::string ce_key_current_path = get_ce_key_current_path(directory_path);
bigbiffbbbfe172021-05-30 15:52:41 -0400728 if (retrieveKey(ce_key_current_path, retrieve_auth, &ce_key, true)) {
bigbiffa957f072021-03-07 18:20:29 -0500729 LOG(INFO) << "Successfully retrieved key";
730 // TODO(147732812): Remove this once Locksettingservice is fixed.
731 // Currently it calls fscrypt_clear_user_key_auth with a secret when lockscreen is
732 // changed from swipe to none or vice-versa
bigbiffbbbfe172021-05-30 15:52:41 -0400733 } else if (retrieveKey(ce_key_current_path, kEmptyAuthentication, &ce_key, true)) {
bigbiffa957f072021-03-07 18:20:29 -0500734 LOG(INFO) << "Successfully retrieved key with empty auth";
735 } else {
736 LOG(ERROR) << "Failed to retrieve key for user " << user_id;
737 return false;
738 }
739 auto const paths = get_ce_key_paths(directory_path);
740 std::string ce_key_path;
741 if (!get_ce_key_new_path(directory_path, paths, &ce_key_path)) return false;
742 if (!::storeKeyAtomically(ce_key_path, user_key_temp, store_auth, ce_key))
743 return false;
744 if (!::FsyncDirectory(directory_path)) return false;
745 return true;
bigbiff7ba75002020-04-11 20:47:09 -0400746}
747
748bool fscrypt_add_user_key_auth(userid_t user_id, int serial, const std::string& token_hex,
749 const std::string& secret_hex) {
bigbiffa957f072021-03-07 18:20:29 -0500750 LOG(INFO) << "fscrypt_add_user_key_auth " << user_id << " serial=" << serial
bigbiff7ba75002020-04-11 20:47:09 -0400751 << " token_present=" << (token_hex != "!");
752 if (!fscrypt_is_native()) return true;
bigbiffa957f072021-03-07 18:20:29 -0500753 auto auth = authentication_from_hex(token_hex, secret_hex);
754 if (!auth) return false;
755 return fscrypt_rewrap_user_key(user_id, serial, kEmptyAuthentication, *auth);
bigbiff7ba75002020-04-11 20:47:09 -0400756}
757
mauronofrio matarrese79820322020-05-25 19:48:56 +0200758bool fscrypt_clear_user_key_auth(userid_t user_id, int serial, const std::string& token_hex,
759 const std::string& secret_hex) {
bigbiffa957f072021-03-07 18:20:29 -0500760 LOG(INFO) << "fscrypt_clear_user_key_auth " << user_id << " serial=" << serial
mauronofrio matarrese79820322020-05-25 19:48:56 +0200761 << " token_present=" << (token_hex != "!");
762 if (!fscrypt_is_native()) return true;
bigbiffa957f072021-03-07 18:20:29 -0500763 auto auth = authentication_from_hex(token_hex, secret_hex);
764 if (!auth) return false;
765 return fscrypt_rewrap_user_key(user_id, serial, *auth, kEmptyAuthentication);
mauronofrio matarrese79820322020-05-25 19:48:56 +0200766}
767
bigbiff7ba75002020-04-11 20:47:09 -0400768bool fscrypt_fixate_newest_user_key_auth(userid_t user_id) {
bigbiffa957f072021-03-07 18:20:29 -0500769 LOG(INFO) << "fscrypt_fixate_newest_user_key_auth " << user_id;
bigbiff7ba75002020-04-11 20:47:09 -0400770 if (!fscrypt_is_native()) return true;
771 if (s_ephemeral_users.count(user_id) != 0) return true;
772 auto const directory_path = get_ce_key_directory_path(user_id);
773 auto const paths = get_ce_key_paths(directory_path);
774 if (paths.empty()) {
775 LOG(ERROR) << "No ce keys present, cannot fixate for user " << user_id;
776 return false;
777 }
778 fixate_user_ce_key(directory_path, paths[0], paths);
779 return true;
780}
781
782// TODO: rename to 'install' for consistency, and take flags to know which keys to install
783bool fscrypt_unlock_user_key(userid_t user_id, int serial, const std::string& token_hex,
784 const std::string& secret_hex) {
bigbiffa957f072021-03-07 18:20:29 -0500785 LOG(INFO) << "fscrypt_unlock_user_key " << user_id << " serial=" << serial
bigbiff7ba75002020-04-11 20:47:09 -0400786 << " token_present=" << (token_hex != "!");
787 if (fscrypt_is_native()) {
bigbiffa957f072021-03-07 18:20:29 -0500788 if (s_ce_policies.count(user_id) != 0) {
bigbiff7ba75002020-04-11 20:47:09 -0400789 LOG(WARNING) << "Tried to unlock already-unlocked key for user " << user_id;
790 return true;
791 }
bigbiffa957f072021-03-07 18:20:29 -0500792 auto auth = authentication_from_hex(token_hex, secret_hex);
793 if (!auth) return false;
794 if (!read_and_install_user_ce_key(user_id, *auth)) {
bigbiff7ba75002020-04-11 20:47:09 -0400795 LOG(ERROR) << "Couldn't read key for " << user_id;
796 return false;
797 }
798 } else {
799 // When in emulation mode, we just use chmod. However, we also
800 // unlock directories when not in emulation mode, to bring devices
801 // back into a known-good state.
bigbiffa957f072021-03-07 18:20:29 -0500802 if (!emulated_unlock(::BuildDataSystemCePath(user_id), 0771) ||
803 !emulated_unlock(::BuildDataMiscCePath(user_id), 01771) ||
804 !emulated_unlock(::BuildDataMediaCePath("", user_id), 0770) ||
805 !emulated_unlock(::BuildDataUserCePath("", user_id), 0771)) {
bigbiff7ba75002020-04-11 20:47:09 -0400806 LOG(ERROR) << "Failed to unlock user " << user_id;
807 return false;
808 }
809 }
810 return true;
811}
812
813// TODO: rename to 'evict' for consistency
814bool fscrypt_lock_user_key(userid_t user_id) {
bigbiffa957f072021-03-07 18:20:29 -0500815 LOG(INFO) << "fscrypt_lock_user_key " << user_id;
bigbiff7ba75002020-04-11 20:47:09 -0400816 if (fscrypt_is_native()) {
817 return evict_ce_key(user_id);
818 } else if (fscrypt_is_emulated()) {
819 // When in emulation mode, we just use chmod
bigbiffa957f072021-03-07 18:20:29 -0500820 if (!emulated_lock(::BuildDataSystemCePath(user_id)) ||
821 !emulated_lock(::BuildDataMiscCePath(user_id)) ||
822 !emulated_lock(::BuildDataMediaCePath("", user_id)) ||
823 !emulated_lock(::BuildDataUserCePath("", user_id))) {
bigbiff7ba75002020-04-11 20:47:09 -0400824 LOG(ERROR) << "Failed to lock user " << user_id;
825 return false;
826 }
827 }
828
829 return true;
830}
831
832static bool prepare_subdirs(const std::string& action, const std::string& volume_uuid,
833 userid_t user_id, int flags) {
bigbiffa957f072021-03-07 18:20:29 -0500834 if (0 != ::ForkExecvp(
bigbiff7ba75002020-04-11 20:47:09 -0400835 std::vector<std::string>{prepare_subdirs_path, action, volume_uuid,
836 std::to_string(user_id), std::to_string(flags)})) {
837 LOG(ERROR) << "vold_prepare_subdirs failed";
838 return false;
839 }
840 return true;
841}
842
843bool fscrypt_prepare_user_storage(const std::string& volume_uuid, userid_t user_id, int serial,
844 int flags) {
bigbiffa957f072021-03-07 18:20:29 -0500845 LOG(INFO) << "fscrypt_prepare_user_storage for volume " << escape_empty(volume_uuid)
bigbiff7ba75002020-04-11 20:47:09 -0400846 << ", user " << user_id << ", serial " << serial << ", flags " << flags;
847
bigbiffa957f072021-03-07 18:20:29 -0500848 if (flags & android::os::IVold::STORAGE_FLAG_DE) {
bigbiff7ba75002020-04-11 20:47:09 -0400849 // DE_sys key
bigbiffa957f072021-03-07 18:20:29 -0500850 auto system_legacy_path = ::BuildDataSystemLegacyPath(user_id);
851 auto misc_legacy_path = ::BuildDataMiscLegacyPath(user_id);
852 auto profiles_de_path = ::BuildDataProfilesDePath(user_id);
bigbiff7ba75002020-04-11 20:47:09 -0400853
854 // DE_n key
bigbiffa957f072021-03-07 18:20:29 -0500855 auto system_de_path = ::BuildDataSystemDePath(user_id);
856 auto misc_de_path = ::BuildDataMiscDePath(user_id);
857 auto vendor_de_path = ::BuildDataVendorDePath(user_id);
858 auto user_de_path = ::BuildDataUserDePath(volume_uuid, user_id);
bigbiff7ba75002020-04-11 20:47:09 -0400859
860 if (volume_uuid.empty()) {
861 if (!prepare_dir(system_legacy_path, 0700, AID_SYSTEM, AID_SYSTEM)) return false;
862#if MANAGE_MISC_DIRS
863 if (!prepare_dir(misc_legacy_path, 0750, multiuser_get_uid(user_id, AID_SYSTEM),
864 multiuser_get_uid(user_id, AID_EVERYBODY)))
865 return false;
866#endif
867 if (!prepare_dir(profiles_de_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
868
869 if (!prepare_dir(system_de_path, 0770, AID_SYSTEM, AID_SYSTEM)) return false;
870 if (!prepare_dir(misc_de_path, 01771, AID_SYSTEM, AID_MISC)) return false;
871 if (!prepare_dir(vendor_de_path, 0771, AID_ROOT, AID_ROOT)) return false;
872 }
873 if (!prepare_dir(user_de_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400874 if (fscrypt_is_native()) {
bigbiffa957f072021-03-07 18:20:29 -0500875 EncryptionPolicy de_policy;
bigbiff7ba75002020-04-11 20:47:09 -0400876 if (volume_uuid.empty()) {
bigbiffa957f072021-03-07 18:20:29 -0500877 if (!lookup_policy(s_de_policies, user_id, &de_policy)) return false;
Darth9ffb034e2022-02-25 07:51:59 +0000878 if (!EnsurePolicy(de_policy, system_de_path))
879 LOG(INFO) << "EnsurePolicy returned false for " << system_de_path;
880 if (!EnsurePolicy(de_policy, misc_de_path))
881 LOG(INFO) << "EnsurePolicy returned false for " << misc_de_path;
882 if (!EnsurePolicy(de_policy, vendor_de_path))
883 LOG(INFO) << "EnsurePolicy returned false for " << vendor_de_path;
bigbiff7ba75002020-04-11 20:47:09 -0400884 } else {
bigbiffa957f072021-03-07 18:20:29 -0500885 if (!read_or_create_volkey(misc_de_path, volume_uuid, &de_policy)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400886 }
Darth9ffb034e2022-02-25 07:51:59 +0000887 if (!EnsurePolicy(de_policy, user_de_path))
888 LOG(INFO) << "EnsurePolicy returned false for " << user_de_path;
889
bigbiff7ba75002020-04-11 20:47:09 -0400890 }
891 }
bigbiffa957f072021-03-07 18:20:29 -0500892
893 if (flags & android::os::IVold::STORAGE_FLAG_CE) {
bigbiff7ba75002020-04-11 20:47:09 -0400894 // CE_n key
bigbiffa957f072021-03-07 18:20:29 -0500895 auto system_ce_path = ::BuildDataSystemCePath(user_id);
896 auto misc_ce_path = ::BuildDataMiscCePath(user_id);
897 auto vendor_ce_path = ::BuildDataVendorCePath(user_id);
898 auto media_ce_path = ::BuildDataMediaCePath(volume_uuid, user_id);
899 auto user_ce_path = ::BuildDataUserCePath(volume_uuid, user_id);
bigbiff7ba75002020-04-11 20:47:09 -0400900
901 if (volume_uuid.empty()) {
902 if (!prepare_dir(system_ce_path, 0770, AID_SYSTEM, AID_SYSTEM)) return false;
903 if (!prepare_dir(misc_ce_path, 01771, AID_SYSTEM, AID_MISC)) return false;
904 if (!prepare_dir(vendor_ce_path, 0771, AID_ROOT, AID_ROOT)) return false;
905 }
906 if (!prepare_dir(media_ce_path, 0770, AID_MEDIA_RW, AID_MEDIA_RW)) return false;
bigbiffa957f072021-03-07 18:20:29 -0500907
bigbiff7ba75002020-04-11 20:47:09 -0400908 if (!prepare_dir(user_ce_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
909
910 if (fscrypt_is_native()) {
bigbiffa957f072021-03-07 18:20:29 -0500911 EncryptionPolicy ce_policy;
bigbiff7ba75002020-04-11 20:47:09 -0400912 if (volume_uuid.empty()) {
bigbiffa957f072021-03-07 18:20:29 -0500913 if (!lookup_policy(s_ce_policies, user_id, &ce_policy)) return false;
Darth9ffb034e2022-02-25 07:51:59 +0000914 if (!EnsurePolicy(ce_policy, system_ce_path))
915 LOG(INFO) << "EnsurePolicy returned false for " << system_ce_path;
916 if (!EnsurePolicy(ce_policy, misc_ce_path))
917 LOG(INFO) << "EnsurePolicy returned false for " << misc_ce_path;
918 if (!EnsurePolicy(ce_policy, vendor_ce_path))
919 LOG(INFO) << "EnsurePolicy returned false for " << vendor_ce_path;
bigbiff7ba75002020-04-11 20:47:09 -0400920 } else {
bigbiffa957f072021-03-07 18:20:29 -0500921 if (!read_or_create_volkey(misc_ce_path, volume_uuid, &ce_policy)) return false;
bigbiff7ba75002020-04-11 20:47:09 -0400922 }
Darth9ffb034e2022-02-25 07:51:59 +0000923 if (!EnsurePolicy(ce_policy, media_ce_path))
924 LOG(INFO) << "EnsurePolicy returned false for " << media_ce_path;
925 if (!EnsurePolicy(ce_policy, user_ce_path))
926 LOG(INFO) << "EnsurePolicy returned false for " << user_ce_path;
bigbiff7ba75002020-04-11 20:47:09 -0400927 }
928
929 if (volume_uuid.empty()) {
930 // Now that credentials have been installed, we can run restorecon
931 // over these paths
932 // NOTE: these paths need to be kept in sync with libselinux
bigbiffa957f072021-03-07 18:20:29 -0500933 ::RestoreconRecursive(system_ce_path);
934 ::RestoreconRecursive(vendor_ce_path);
935 ::RestoreconRecursive(misc_ce_path);
bigbiff7ba75002020-04-11 20:47:09 -0400936 }
937 }
938 if (!prepare_subdirs("prepare", volume_uuid, user_id, flags)) return false;
939
940 return true;
941}
942
943bool fscrypt_destroy_user_storage(const std::string& volume_uuid, userid_t user_id, int flags) {
bigbiffa957f072021-03-07 18:20:29 -0500944 LOG(INFO) << "fscrypt_destroy_user_storage for volume " << escape_empty(volume_uuid)
bigbiff7ba75002020-04-11 20:47:09 -0400945 << ", user " << user_id << ", flags " << flags;
946 bool res = true;
947
948 res &= prepare_subdirs("destroy", volume_uuid, user_id, flags);
949
bigbiffa957f072021-03-07 18:20:29 -0500950 if (flags & android::os::IVold::STORAGE_FLAG_CE) {
bigbiff7ba75002020-04-11 20:47:09 -0400951 // CE_n key
bigbiffa957f072021-03-07 18:20:29 -0500952 auto system_ce_path = ::BuildDataSystemCePath(user_id);
953 auto misc_ce_path = ::BuildDataMiscCePath(user_id);
954 auto vendor_ce_path = ::BuildDataVendorCePath(user_id);
955 auto media_ce_path = ::BuildDataMediaCePath(volume_uuid, user_id);
956 auto user_ce_path = ::BuildDataUserCePath(volume_uuid, user_id);
bigbiff7ba75002020-04-11 20:47:09 -0400957
958 res &= destroy_dir(media_ce_path);
959 res &= destroy_dir(user_ce_path);
960 if (volume_uuid.empty()) {
961 res &= destroy_dir(system_ce_path);
962 res &= destroy_dir(misc_ce_path);
963 res &= destroy_dir(vendor_ce_path);
964 } else {
965 if (fscrypt_is_native()) {
966 res &= destroy_volkey(misc_ce_path, volume_uuid);
967 }
968 }
969 }
970
bigbiffa957f072021-03-07 18:20:29 -0500971 if (flags & android::os::IVold::STORAGE_FLAG_DE) {
bigbiff7ba75002020-04-11 20:47:09 -0400972 // DE_sys key
bigbiffa957f072021-03-07 18:20:29 -0500973 auto system_legacy_path = ::BuildDataSystemLegacyPath(user_id);
974 auto misc_legacy_path = ::BuildDataMiscLegacyPath(user_id);
975 auto profiles_de_path = ::BuildDataProfilesDePath(user_id);
bigbiff7ba75002020-04-11 20:47:09 -0400976
977 // DE_n key
bigbiffa957f072021-03-07 18:20:29 -0500978 auto system_de_path = ::BuildDataSystemDePath(user_id);
979 auto misc_de_path = ::BuildDataMiscDePath(user_id);
980 auto vendor_de_path = ::BuildDataVendorDePath(user_id);
981 auto user_de_path = ::BuildDataUserDePath(volume_uuid, user_id);
bigbiff7ba75002020-04-11 20:47:09 -0400982
983 res &= destroy_dir(user_de_path);
984 if (volume_uuid.empty()) {
985 res &= destroy_dir(system_legacy_path);
986#if MANAGE_MISC_DIRS
987 res &= destroy_dir(misc_legacy_path);
988#endif
989 res &= destroy_dir(profiles_de_path);
990 res &= destroy_dir(system_de_path);
991 res &= destroy_dir(misc_de_path);
992 res &= destroy_dir(vendor_de_path);
993 } else {
994 if (fscrypt_is_native()) {
995 res &= destroy_volkey(misc_de_path, volume_uuid);
996 }
997 }
998 }
999
1000 return res;
1001}
1002
1003static bool destroy_volume_keys(const std::string& directory_path, const std::string& volume_uuid) {
1004 auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(directory_path.c_str()), closedir);
1005 if (!dirp) {
1006 PLOG(ERROR) << "Unable to open directory: " + directory_path;
1007 return false;
1008 }
1009 bool res = true;
1010 for (;;) {
1011 errno = 0;
1012 auto const entry = readdir(dirp.get());
1013 if (!entry) {
1014 if (errno) {
1015 PLOG(ERROR) << "Unable to read directory: " + directory_path;
1016 return false;
1017 }
1018 break;
1019 }
1020 if (entry->d_type != DT_DIR || entry->d_name[0] == '.') {
bigbiffa957f072021-03-07 18:20:29 -05001021 LOG(INFO) << "Skipping non-user " << entry->d_name;
bigbiff7ba75002020-04-11 20:47:09 -04001022 continue;
1023 }
1024 res &= destroy_volkey(directory_path + "/" + entry->d_name, volume_uuid);
1025 }
1026 return res;
1027}
1028
1029bool fscrypt_destroy_volume_keys(const std::string& volume_uuid) {
1030 bool res = true;
bigbiffa957f072021-03-07 18:20:29 -05001031 LOG(INFO) << "fscrypt_destroy_volume_keys for volume " << escape_empty(volume_uuid);
bigbiff7ba75002020-04-11 20:47:09 -04001032 auto secdiscardable_path = volume_secdiscardable_path(volume_uuid);
bigbiffa957f072021-03-07 18:20:29 -05001033 res &= ::runSecdiscardSingle(secdiscardable_path);
bigbiff7ba75002020-04-11 20:47:09 -04001034 res &= destroy_volume_keys("/data/misc_ce", volume_uuid);
1035 res &= destroy_volume_keys("/data/misc_de", volume_uuid);
1036 return res;
1037}
bigbiffa957f072021-03-07 18:20:29 -05001038
1039bool lookup_key_ref(const std::map<userid_t, android::fscrypt::EncryptionPolicy>& key_map, userid_t user_id,
1040 std::string* raw_ref) {
1041 auto refi = key_map.find(user_id);
1042 if (refi == key_map.end()) {
1043 LOG(ERROR) << "Cannot find key for " << user_id;
1044 return false;
1045 }
1046 *raw_ref = refi->second.key_raw_ref;
1047 return true;
1048}