Ext4Crypt.cpp

   1 /*
   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 "Ext4Crypt.h"
  18
  19 #include "KeyStorage.h"
  20 #include "Utils.h"
  21
  22 #include <algorithm>
  23 #include <iomanip>
  24 #include <map>
  25 #include <set>
  26 #include <sstream>
  27 #include <string>
  28
  29 #include <dirent.h>
  30 #include <errno.h>
  31 #include <fcntl.h>
  32 #include <limits.h>
  33 #include <openssl/sha.h>
  34 #include <selinux/android.h>
  35 #include <stdio.h>
  36 #include <sys/mount.h>
  37 #include <sys/stat.h>
  38 #include <sys/types.h>
  39
  40 #include <private/android_filesystem_config.h>
  41
  42 #include "cryptfs.h"
  43 #include "ext4_crypt.h"
  44 #include "key_control.h"
  45
  46 #define EMULATED_USES_SELINUX 0
  47 #define MANAGE_MISC_DIRS 0
  48
  49 #include <cutils/fs.h>
  50
  51 #include <android-base/file.h>
  52 #include <android-base/logging.h>
  53 #include <android-base/stringprintf.h>
  54
  55 using android::base::StringPrintf;
  56 using android::vold::kEmptyAuthentication;
  57
  58 // NOTE: keep in sync with StorageManager
  59 static constexpr int FLAG_STORAGE_DE = 1 << 0;
  60 static constexpr int FLAG_STORAGE_CE = 1 << 1;
  61
  62 namespace {
  63 const std::string device_key_dir = std::string() + DATA_MNT_POINT + e4crypt_unencrypted_folder;
  64 const std::string device_key_path = device_key_dir + "/key";
  65 const std::string device_key_temp = device_key_dir + "/temp";
  66
  67 const std::string user_key_dir = std::string() + DATA_MNT_POINT + "/misc/vold/user_keys";
  68 const std::string user_key_temp = user_key_dir + "/temp";
  69
  70 bool s_global_de_initialized = false;
  71
  72 // Some users are ephemeral, don't try to wipe their keys from disk
  73 std::set<userid_t> s_ephemeral_users;
  74
  75 // Map user ids to key references
  76 std::map<userid_t, std::string> s_de_key_raw_refs;
  77 std::map<userid_t, std::string> s_ce_key_raw_refs;
  78 // TODO abolish this map. Keys should not be long-lived in user memory, only kernel memory.
  79 // See b/26948053
  80 std::map<userid_t, std::string> s_ce_keys;
  81
  82 // ext4enc:TODO get this const from somewhere good
  83 const int EXT4_KEY_DESCRIPTOR_SIZE = 8;
  84
  85 // ext4enc:TODO Include structure from somewhere sensible
  86 // MUST be in sync with ext4_crypto.c in kernel
  87 constexpr int EXT4_ENCRYPTION_MODE_AES_256_XTS = 1;
  88 constexpr int EXT4_AES_256_XTS_KEY_SIZE = 64;
  89 constexpr int EXT4_MAX_KEY_SIZE = 64;
  90 struct ext4_encryption_key {
  91     uint32_t mode;
  92     char raw[EXT4_MAX_KEY_SIZE];
  93     uint32_t size;
  94 };
  95 }
  96
  97 static bool e4crypt_is_emulated() {
  98     return property_get_bool("persist.sys.emulate_fbe", false);
  99 }
 100
 101 static const char* escape_null(const char* value) {
 102     return (value == nullptr) ? "null" : value;
 103 }
 104
 105 // Get raw keyref - used to make keyname and to pass to ioctl
 106 static std::string generate_key_ref(const char* key, int length) {
 107     SHA512_CTX c;
 108
 109     SHA512_Init(&c);
 110     SHA512_Update(&c, key, length);
 111     unsigned char key_ref1[SHA512_DIGEST_LENGTH];
 112     SHA512_Final(key_ref1, &c);
 113
 114     SHA512_Init(&c);
 115     SHA512_Update(&c, key_ref1, SHA512_DIGEST_LENGTH);
 116     unsigned char key_ref2[SHA512_DIGEST_LENGTH];
 117     SHA512_Final(key_ref2, &c);
 118
 119     static_assert(EXT4_KEY_DESCRIPTOR_SIZE <= SHA512_DIGEST_LENGTH,
 120                   "Hash too short for descriptor");
 121     return std::string((char*)key_ref2, EXT4_KEY_DESCRIPTOR_SIZE);
 122 }
 123
 124 static bool fill_key(const std::string& key, ext4_encryption_key* ext4_key) {
 125     if (key.size() != EXT4_AES_256_XTS_KEY_SIZE) {
 126         LOG(ERROR) << "Wrong size key " << key.size();
 127         return false;
 128     }
 129     static_assert(EXT4_AES_256_XTS_KEY_SIZE <= sizeof(ext4_key->raw), "Key too long!");
 130     ext4_key->mode = EXT4_ENCRYPTION_MODE_AES_256_XTS;
 131     ext4_key->size = key.size();
 132     memset(ext4_key->raw, 0, sizeof(ext4_key->raw));
 133     memcpy(ext4_key->raw, key.data(), key.size());
 134     return true;
 135 }
 136
 137 static std::string keyname(const std::string& raw_ref) {
 138     std::ostringstream o;
 139     o << "ext4:";
 140     for (auto i : raw_ref) {
 141         o << std::hex << std::setw(2) << std::setfill('0') << (int)i;
 142     }
 143     return o.str();
 144 }
 145
 146 // Get the keyring we store all keys in
 147 static bool e4crypt_keyring(key_serial_t* device_keyring) {
 148     *device_keyring = keyctl_search(KEY_SPEC_SESSION_KEYRING, "keyring", "e4crypt", 0);
 149     if (*device_keyring == -1) {
 150         PLOG(ERROR) << "Unable to find device keyring";
 151         return false;
 152     }
 153     return true;
 154 }
 155
 156 // Install password into global keyring
 157 // Return raw key reference for use in policy
 158 static bool install_key(const std::string& key, std::string* raw_ref) {
 159     ext4_encryption_key ext4_key;
 160     if (!fill_key(key, &ext4_key)) return false;
 161     *raw_ref = generate_key_ref(ext4_key.raw, ext4_key.size);
 162     auto ref = keyname(*raw_ref);
 163     key_serial_t device_keyring;
 164     if (!e4crypt_keyring(&device_keyring)) return false;
 165     key_serial_t key_id =
 166         add_key("logon", ref.c_str(), (void*)&ext4_key, sizeof(ext4_key), device_keyring);
 167     if (key_id == -1) {
 168         PLOG(ERROR) << "Failed to insert key into keyring " << device_keyring;
 169         return false;
 170     }
 171     LOG(DEBUG) << "Added key " << key_id << " (" << ref << ") to keyring " << device_keyring
 172                << " in process " << getpid();
 173     return true;
 174 }
 175
 176 static std::string get_de_key_path(userid_t user_id) {
 177     return StringPrintf("%s/de/%d", user_key_dir.c_str(), user_id);
 178 }
 179
 180 static std::string get_ce_key_directory_path(userid_t user_id) {
 181     return StringPrintf("%s/ce/%d", user_key_dir.c_str(), user_id);
 182 }
 183
 184 // Returns the keys newest first
 185 static std::vector<std::string> get_ce_key_paths(const std::string& directory_path) {
 186     auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(directory_path.c_str()), closedir);
 187     if (!dirp) {
 188         PLOG(ERROR) << "Unable to open ce key directory: " + directory_path;
 189         return std::vector<std::string>();
 190     }
 191     std::vector<std::string> result;
 192     for (;;) {
 193         errno = 0;
 194         auto const entry = readdir(dirp.get());
 195         if (!entry) {
 196             if (errno) {
 197                 PLOG(ERROR) << "Unable to read ce key directory: " + directory_path;
 198                 return std::vector<std::string>();
 199             }
 200             break;
 201         }
 202         if (entry->d_type != DT_DIR || entry->d_name[0] != 'c') {
 203             LOG(DEBUG) << "Skipping non-key " << entry->d_name;
 204             continue;
 205         }
 206         result.emplace_back(directory_path + "/" + entry->d_name);
 207     }
 208     std::sort(result.begin(), result.end());
 209     std::reverse(result.begin(), result.end());
 210     return result;
 211 }
 212
 213 static std::string get_ce_key_current_path(const std::string& directory_path) {
 214     return directory_path + "/current";
 215 }
 216
 217 static bool get_ce_key_new_path(const std::string& directory_path,
 218                                 const std::vector<std::string>& paths,
 219                                 std::string *ce_key_path) {
 220     if (paths.empty()) {
 221         *ce_key_path = get_ce_key_current_path(directory_path);
 222         return true;
 223     }
 224     for (unsigned int i = 0; i < UINT_MAX; i++) {
 225         auto const candidate = StringPrintf("%s/cx%010u", directory_path.c_str(), i);
 226         if (paths[0] < candidate) {
 227             *ce_key_path = candidate;
 228             return true;
 229         }
 230     }
 231     return false;
 232 }
 233
 234 // Discard all keys but the named one; rename it to canonical name.
 235 // No point in acting on errors in this; ignore them.
 236 static void fixate_user_ce_key(const std::string& directory_path, const std::string &to_fix,
 237                                const std::vector<std::string>& paths) {
 238     for (auto const other_path: paths) {
 239         if (other_path != to_fix) {
 240             android::vold::destroyKey(other_path);
 241         }
 242     }
 243     auto const current_path = get_ce_key_current_path(directory_path);
 244     if (to_fix != current_path) {
 245         LOG(DEBUG) << "Renaming " << to_fix << " to " << current_path;
 246         if (rename(to_fix.c_str(), current_path.c_str()) != 0) {
 247             PLOG(WARNING) << "Unable to rename " << to_fix << " to " << current_path;
 248         }
 249     }
 250 }
 251
 252 static bool read_and_fixate_user_ce_key(userid_t user_id,
 253                                         const android::vold::KeyAuthentication& auth,
 254                                         std::string *ce_key) {
 255     auto const directory_path = get_ce_key_directory_path(user_id);
 256     auto const paths = get_ce_key_paths(directory_path);
 257     for (auto const ce_key_path: paths) {
 258         LOG(DEBUG) << "Trying user CE key " << ce_key_path;
 259         if (android::vold::retrieveKey(ce_key_path, auth, ce_key)) {
 260             LOG(DEBUG) << "Successfully retrieved key";
 261             fixate_user_ce_key(directory_path, ce_key_path, paths);
 262             return true;
 263         }
 264     }
 265     LOG(ERROR) << "Failed to find working ce key for user " << user_id;
 266     return false;
 267 }
 268
 269 static bool read_and_install_user_ce_key(userid_t user_id,
 270                                          const android::vold::KeyAuthentication& auth) {
 271     if (s_ce_key_raw_refs.count(user_id) != 0) return true;
 272     std::string ce_key;
 273     if (!read_and_fixate_user_ce_key(user_id, auth, &ce_key)) return false;
 274     std::string ce_raw_ref;
 275     if (!install_key(ce_key, &ce_raw_ref)) return false;
 276     s_ce_keys[user_id] = ce_key;
 277     s_ce_key_raw_refs[user_id] = ce_raw_ref;
 278     LOG(DEBUG) << "Installed ce key for user " << user_id;
 279     return true;
 280 }
 281
 282 static bool prepare_dir(const std::string& dir, mode_t mode, uid_t uid, gid_t gid) {
 283     LOG(DEBUG) << "Preparing: " << dir;
 284     if (fs_prepare_dir(dir.c_str(), mode, uid, gid) != 0) {
 285         PLOG(ERROR) << "Failed to prepare " << dir;
 286         return false;
 287     }
 288     return true;
 289 }
 290
 291 static bool destroy_dir(const std::string& dir) {
 292     LOG(DEBUG) << "Destroying: " << dir;
 293     if (rmdir(dir.c_str()) != 0 && errno != ENOENT) {
 294         PLOG(ERROR) << "Failed to destroy " << dir;
 295         return false;
 296     }
 297     return true;
 298 }
 299
 300 static bool random_key(std::string* key) {
 301     if (android::vold::ReadRandomBytes(EXT4_AES_256_XTS_KEY_SIZE, *key) != 0) {
 302         // TODO status_t plays badly with PLOG, fix it.
 303         LOG(ERROR) << "Random read failed";
 304         return false;
 305     }
 306     return true;
 307 }
 308
 309 static bool path_exists(const std::string& path) {
 310     return access(path.c_str(), F_OK) == 0;
 311 }
 312
 313 // NB this assumes that there is only one thread listening for crypt commands, because
 314 // it creates keys in a fixed location.
 315 static bool store_key(const std::string& key_path, const std::string& tmp_path,
 316                       const android::vold::KeyAuthentication& auth, const std::string& key) {
 317     if (path_exists(key_path)) {
 318         LOG(ERROR) << "Already exists, cannot create key at: " << key_path;
 319         return false;
 320     }
 321     if (path_exists(tmp_path)) {
 322         android::vold::destroyKey(tmp_path);  // May be partially created so ignore errors
 323     }
 324     if (!android::vold::storeKey(tmp_path, auth, key)) return false;
 325     if (rename(tmp_path.c_str(), key_path.c_str()) != 0) {
 326         PLOG(ERROR) << "Unable to move new key to location: " << key_path;
 327         return false;
 328     }
 329     LOG(DEBUG) << "Created key " << key_path;
 330     return true;
 331 }
 332
 333 static bool create_and_install_user_keys(userid_t user_id, bool create_ephemeral) {
 334     std::string de_key, ce_key;
 335     if (!random_key(&de_key)) return false;
 336     if (!random_key(&ce_key)) return false;
 337     if (create_ephemeral) {
 338         // If the key should be created as ephemeral, don't store it.
 339         s_ephemeral_users.insert(user_id);
 340     } else {
 341         auto const directory_path = get_ce_key_directory_path(user_id);
 342         if (!prepare_dir(directory_path, 0700, AID_ROOT, AID_ROOT)) return false;
 343         auto const paths = get_ce_key_paths(directory_path);
 344         std::string ce_key_path;
 345         if (!get_ce_key_new_path(directory_path, paths, &ce_key_path)) return false;
 346         if (!store_key(ce_key_path, user_key_temp,
 347                 kEmptyAuthentication, ce_key)) return false;
 348         fixate_user_ce_key(directory_path, ce_key_path, paths);
 349         // Write DE key second; once this is written, all is good.
 350         if (!store_key(get_de_key_path(user_id), user_key_temp,
 351                 kEmptyAuthentication, de_key)) return false;
 352     }
 353     std::string de_raw_ref;
 354     if (!install_key(de_key, &de_raw_ref)) return false;
 355     s_de_key_raw_refs[user_id] = de_raw_ref;
 356     std::string ce_raw_ref;
 357     if (!install_key(ce_key, &ce_raw_ref)) return false;
 358     s_ce_keys[user_id] = ce_key;
 359     s_ce_key_raw_refs[user_id] = ce_raw_ref;
 360     LOG(DEBUG) << "Created keys for user " << user_id;
 361     return true;
 362 }
 363
 364 static bool lookup_key_ref(const std::map<userid_t, std::string>& key_map, userid_t user_id,
 365                            std::string* raw_ref) {
 366     auto refi = key_map.find(user_id);
 367     if (refi == key_map.end()) {
 368         LOG(ERROR) << "Cannot find key for " << user_id;
 369         return false;
 370     }
 371     *raw_ref = refi->second;
 372     return true;
 373 }
 374
 375 static bool ensure_policy(const std::string& raw_ref, const std::string& path) {
 376     if (e4crypt_policy_ensure(path.c_str(), raw_ref.data(), raw_ref.size()) != 0) {
 377         LOG(ERROR) << "Failed to set policy on: " << path;
 378         return false;
 379     }
 380     return true;
 381 }
 382
 383 static bool is_numeric(const char* name) {
 384     for (const char* p = name; *p != '\0'; p++) {
 385         if (!isdigit(*p)) return false;
 386     }
 387     return true;
 388 }
 389
 390 static bool load_all_de_keys() {
 391     auto de_dir = user_key_dir + "/de";
 392     auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(de_dir.c_str()), closedir);
 393     if (!dirp) {
 394         PLOG(ERROR) << "Unable to read de key directory";
 395         return false;
 396     }
 397     for (;;) {
 398         errno = 0;
 399         auto entry = readdir(dirp.get());
 400         if (!entry) {
 401             if (errno) {
 402                 PLOG(ERROR) << "Unable to read de key directory";
 403                 return false;
 404             }
 405             break;
 406         }
 407         if (entry->d_type != DT_DIR || !is_numeric(entry->d_name)) {
 408             LOG(DEBUG) << "Skipping non-de-key " << entry->d_name;
 409             continue;
 410         }
 411         userid_t user_id = atoi(entry->d_name);
 412         if (s_de_key_raw_refs.count(user_id) == 0) {
 413             auto key_path = de_dir + "/" + entry->d_name;
 414             std::string key;
 415             if (!android::vold::retrieveKey(key_path, kEmptyAuthentication, &key)) return false;
 416             std::string raw_ref;
 417             if (!install_key(key, &raw_ref)) return false;
 418             s_de_key_raw_refs[user_id] = raw_ref;
 419             LOG(DEBUG) << "Installed de key for user " << user_id;
 420         }
 421     }
 422     // ext4enc:TODO: go through all DE directories, ensure that all user dirs have the
 423     // correct policy set on them, and that no rogue ones exist.
 424     return true;
 425 }
 426
 427 bool e4crypt_initialize_global_de() {
 428     LOG(INFO) << "e4crypt_initialize_global_de";
 429
 430     if (s_global_de_initialized) {
 431         LOG(INFO) << "Already initialized";
 432         return true;
 433     }
 434
 435     std::string device_key;
 436     if (path_exists(device_key_path)) {
 437         if (!android::vold::retrieveKey(device_key_path,
 438                 kEmptyAuthentication, &device_key)) return false;
 439     } else {
 440         LOG(INFO) << "Creating new key";
 441         if (!random_key(&device_key)) return false;
 442         if (!store_key(device_key_path, device_key_temp,
 443                 kEmptyAuthentication, device_key)) return false;
 444     }
 445
 446     std::string device_key_ref;
 447     if (!install_key(device_key, &device_key_ref)) {
 448         LOG(ERROR) << "Failed to install device key";
 449         return false;
 450     }
 451
 452     std::string ref_filename = std::string("/data") + e4crypt_key_ref;
 453     if (!android::base::WriteStringToFile(device_key_ref, ref_filename)) {
 454         PLOG(ERROR) << "Cannot save key reference";
 455         return false;
 456     }
 457
 458     s_global_de_initialized = true;
 459     return true;
 460 }
 461
 462 bool e4crypt_init_user0() {
 463     LOG(DEBUG) << "e4crypt_init_user0";
 464     if (e4crypt_is_native()) {
 465         if (!prepare_dir(user_key_dir, 0700, AID_ROOT, AID_ROOT)) return false;
 466         if (!prepare_dir(user_key_dir + "/ce", 0700, AID_ROOT, AID_ROOT)) return false;
 467         if (!prepare_dir(user_key_dir + "/de", 0700, AID_ROOT, AID_ROOT)) return false;
 468         if (!path_exists(get_de_key_path(0))) {
 469             if (!create_and_install_user_keys(0, false)) return false;
 470         }
 471         // TODO: switch to loading only DE_0 here once framework makes
 472         // explicit calls to install DE keys for secondary users
 473         if (!load_all_de_keys()) return false;
 474     }
 475     // We can only safely prepare DE storage here, since CE keys are probably
 476     // entangled with user credentials.  The framework will always prepare CE
 477     // storage once CE keys are installed.
 478     if (!e4crypt_prepare_user_storage(nullptr, 0, 0, FLAG_STORAGE_DE)) {
 479         LOG(ERROR) << "Failed to prepare user 0 storage";
 480         return false;
 481     }
 482
 483     // If this is a non-FBE device that recently left an emulated mode,
 484     // restore user data directories to known-good state.
 485     if (!e4crypt_is_native() && !e4crypt_is_emulated()) {
 486         e4crypt_unlock_user_key(0, 0, "!", "!");
 487     }
 488
 489     return true;
 490 }
 491
 492 bool e4crypt_vold_create_user_key(userid_t user_id, int serial, bool ephemeral) {
 493     LOG(DEBUG) << "e4crypt_vold_create_user_key for " << user_id << " serial " << serial;
 494     if (!e4crypt_is_native()) {
 495         return true;
 496     }
 497     // FIXME test for existence of key that is not loaded yet
 498     if (s_ce_key_raw_refs.count(user_id) != 0) {
 499         LOG(ERROR) << "Already exists, can't e4crypt_vold_create_user_key for " << user_id
 500                    << " serial " << serial;
 501         // FIXME should we fail the command?
 502         return true;
 503     }
 504     if (!create_and_install_user_keys(user_id, ephemeral)) {
 505         return false;
 506     }
 507     return true;
 508 }
 509
 510 static bool evict_key(const std::string& raw_ref) {
 511     auto ref = keyname(raw_ref);
 512     key_serial_t device_keyring;
 513     if (!e4crypt_keyring(&device_keyring)) return false;
 514     auto key_serial = keyctl_search(device_keyring, "logon", ref.c_str(), 0);
 515     if (keyctl_revoke(key_serial) != 0) {
 516         PLOG(ERROR) << "Failed to revoke key with serial " << key_serial << " ref " << ref;
 517         return false;
 518     }
 519     LOG(DEBUG) << "Revoked key with serial " << key_serial << " ref " << ref;
 520     return true;
 521 }
 522
 523 bool e4crypt_destroy_user_key(userid_t user_id) {
 524     LOG(DEBUG) << "e4crypt_destroy_user_key(" << user_id << ")";
 525     if (!e4crypt_is_native()) {
 526         return true;
 527     }
 528     bool success = true;
 529     s_ce_keys.erase(user_id);
 530     std::string raw_ref;
 531     // If we haven't loaded the CE key, no need to evict it.
 532     if (lookup_key_ref(s_ce_key_raw_refs, user_id, &raw_ref)) {
 533         success &= evict_key(raw_ref);
 534     }
 535     s_ce_key_raw_refs.erase(user_id);
 536     success &= lookup_key_ref(s_de_key_raw_refs, user_id, &raw_ref) && evict_key(raw_ref);
 537     s_de_key_raw_refs.erase(user_id);
 538     auto it = s_ephemeral_users.find(user_id);
 539     if (it != s_ephemeral_users.end()) {
 540         s_ephemeral_users.erase(it);
 541     } else {
 542         for (auto const path: get_ce_key_paths(get_ce_key_directory_path(user_id))) {
 543             success &= android::vold::destroyKey(path);
 544         }
 545         success &= android::vold::destroyKey(get_de_key_path(user_id));
 546     }
 547     return success;
 548 }
 549
 550 static bool emulated_lock(const std::string& path) {
 551     if (chmod(path.c_str(), 0000) != 0) {
 552         PLOG(ERROR) << "Failed to chmod " << path;
 553         return false;
 554     }
 555 #if EMULATED_USES_SELINUX
 556     if (setfilecon(path.c_str(), "u:object_r:storage_stub_file:s0") != 0) {
 557         PLOG(WARNING) << "Failed to setfilecon " << path;
 558         return false;
 559     }
 560 #endif
 561     return true;
 562 }
 563
 564 static bool emulated_unlock(const std::string& path, mode_t mode) {
 565     if (chmod(path.c_str(), mode) != 0) {
 566         PLOG(ERROR) << "Failed to chmod " << path;
 567         // FIXME temporary workaround for b/26713622
 568         if (e4crypt_is_emulated()) return false;
 569     }
 570 #if EMULATED_USES_SELINUX
 571     if (selinux_android_restorecon(path.c_str(), SELINUX_ANDROID_RESTORECON_FORCE) != 0) {
 572         PLOG(WARNING) << "Failed to restorecon " << path;
 573         // FIXME temporary workaround for b/26713622
 574         if (e4crypt_is_emulated()) return false;
 575     }
 576 #endif
 577     return true;
 578 }
 579
 580 static bool parse_hex(const char* hex, std::string* result) {
 581     if (strcmp("!", hex) == 0) {
 582         *result = "";
 583         return true;
 584     }
 585     if (android::vold::HexToStr(hex, *result) != 0) {
 586         LOG(ERROR) << "Invalid FBE hex string";  // Don't log the string for security reasons
 587         return false;
 588     }
 589     return true;
 590 }
 591
 592 bool e4crypt_add_user_key_auth(userid_t user_id, int serial, const char* token_hex,
 593                           const char* secret_hex) {
 594     LOG(DEBUG) << "e4crypt_add_user_key_auth " << user_id << " serial=" << serial
 595                << " token_present=" << (strcmp(token_hex, "!") != 0);
 596     if (!e4crypt_is_native()) return true;
 597     if (s_ephemeral_users.count(user_id) != 0) return true;
 598     std::string token, secret;
 599     if (!parse_hex(token_hex, &token)) return false;
 600     if (!parse_hex(secret_hex, &secret)) return false;
 601     auto auth = secret.empty() ? kEmptyAuthentication
 602                                    : android::vold::KeyAuthentication(token, secret);
 603     auto it = s_ce_keys.find(user_id);
 604     if (it == s_ce_keys.end()) {
 605         LOG(ERROR) << "Key not loaded into memory, can't change for user " << user_id;
 606         return false;
 607     }
 608     auto ce_key = it->second;
 609     auto const directory_path = get_ce_key_directory_path(user_id);
 610     auto const paths = get_ce_key_paths(directory_path);
 611     std::string ce_key_path;
 612     if (!get_ce_key_new_path(directory_path, paths, &ce_key_path)) return false;
 613     if (!store_key(ce_key_path, user_key_temp, auth, ce_key)) return false;
 614     return true;
 615 }
 616
 617 bool e4crypt_fixate_newest_user_key_auth(userid_t user_id) {
 618     LOG(DEBUG) << "e4crypt_fixate_newest_user_key_auth " << user_id;
 619     if (!e4crypt_is_native()) return true;
 620     auto const directory_path = get_ce_key_directory_path(user_id);
 621     auto const paths = get_ce_key_paths(directory_path);
 622     if (paths.empty()) {
 623         LOG(ERROR) << "No ce keys present, cannot fixate for user " << user_id;
 624         return false;
 625     }
 626     fixate_user_ce_key(directory_path, paths[0], paths);
 627     return true;
 628 }
 629
 630 // TODO: rename to 'install' for consistency, and take flags to know which keys to install
 631 bool e4crypt_unlock_user_key(userid_t user_id, int serial, const char* token_hex,
 632                              const char* secret_hex) {
 633     LOG(DEBUG) << "e4crypt_unlock_user_key " << user_id << " serial=" << serial
 634                << " token_present=" << (strcmp(token_hex, "!") != 0);
 635     if (e4crypt_is_native()) {
 636         if (s_ce_key_raw_refs.count(user_id) != 0) {
 637             LOG(WARNING) << "Tried to unlock already-unlocked key for user " << user_id;
 638             return true;
 639         }
 640         std::string token, secret;
 641         if (!parse_hex(token_hex, &token)) return false;
 642         if (!parse_hex(secret_hex, &secret)) return false;
 643         android::vold::KeyAuthentication auth(token, secret);
 644         if (!read_and_install_user_ce_key(user_id, auth)) {
 645             LOG(ERROR) << "Couldn't read key for " << user_id;
 646             return false;
 647         }
 648     } else {
 649         // When in emulation mode, we just use chmod. However, we also
 650         // unlock directories when not in emulation mode, to bring devices
 651         // back into a known-good state.
 652         if (!emulated_unlock(android::vold::BuildDataSystemCePath(user_id), 0771) ||
 653             !emulated_unlock(android::vold::BuildDataMiscCePath(user_id), 01771) ||
 654             !emulated_unlock(android::vold::BuildDataMediaCePath(nullptr, user_id), 0770) ||
 655             !emulated_unlock(android::vold::BuildDataUserCePath(nullptr, user_id), 0771)) {
 656             LOG(ERROR) << "Failed to unlock user " << user_id;
 657             return false;
 658         }
 659     }
 660     return true;
 661 }
 662
 663 // TODO: rename to 'evict' for consistency
 664 bool e4crypt_lock_user_key(userid_t user_id) {
 665     if (e4crypt_is_native()) {
 666         // TODO: remove from kernel keyring
 667     } else if (e4crypt_is_emulated()) {
 668         // When in emulation mode, we just use chmod
 669         if (!emulated_lock(android::vold::BuildDataSystemCePath(user_id)) ||
 670             !emulated_lock(android::vold::BuildDataMiscCePath(user_id)) ||
 671             !emulated_lock(android::vold::BuildDataMediaCePath(nullptr, user_id)) ||
 672             !emulated_lock(android::vold::BuildDataUserCePath(nullptr, user_id))) {
 673             LOG(ERROR) << "Failed to lock user " << user_id;
 674             return false;
 675         }
 676     }
 677
 678     return true;
 679 }
 680
 681 bool e4crypt_prepare_user_storage(const char* volume_uuid, userid_t user_id, int serial,
 682         int flags) {
 683     LOG(DEBUG) << "e4crypt_prepare_user_storage for volume " << escape_null(volume_uuid)
 684                << ", user " << user_id << ", serial " << serial << ", flags " << flags;
 685
 686     if (flags & FLAG_STORAGE_DE) {
 687         // DE_sys key
 688         auto system_legacy_path = android::vold::BuildDataSystemLegacyPath(user_id);
 689         auto misc_legacy_path = android::vold::BuildDataMiscLegacyPath(user_id);
 690         auto profiles_de_path = android::vold::BuildDataProfilesDePath(user_id);
 691         auto foreign_de_path = android::vold::BuildDataProfilesForeignDexDePath(user_id);
 692
 693         // DE_n key
 694         auto system_de_path = android::vold::BuildDataSystemDePath(user_id);
 695         auto misc_de_path = android::vold::BuildDataMiscDePath(user_id);
 696         auto user_de_path = android::vold::BuildDataUserDePath(volume_uuid, user_id);
 697
 698         if (!prepare_dir(system_legacy_path, 0700, AID_SYSTEM, AID_SYSTEM)) return false;
 699 #if MANAGE_MISC_DIRS
 700         if (!prepare_dir(misc_legacy_path, 0750, multiuser_get_uid(user_id, AID_SYSTEM),
 701                 multiuser_get_uid(user_id, AID_EVERYBODY))) return false;
 702 #endif
 703         if (!prepare_dir(profiles_de_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
 704         if (!prepare_dir(foreign_de_path, 0773, AID_SYSTEM, AID_SYSTEM)) return false;
 705
 706         if (!prepare_dir(system_de_path, 0770, AID_SYSTEM, AID_SYSTEM)) return false;
 707         if (!prepare_dir(misc_de_path, 01771, AID_SYSTEM, AID_MISC)) return false;
 708         if (!prepare_dir(user_de_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
 709
 710         // For now, FBE is only supported on internal storage
 711         if (e4crypt_is_native() && volume_uuid == nullptr) {
 712             std::string de_raw_ref;
 713             if (!lookup_key_ref(s_de_key_raw_refs, user_id, &de_raw_ref)) return false;
 714             if (!ensure_policy(de_raw_ref, system_de_path)) return false;
 715             if (!ensure_policy(de_raw_ref, misc_de_path)) return false;
 716             if (!ensure_policy(de_raw_ref, user_de_path)) return false;
 717         }
 718     }
 719
 720     if (flags & FLAG_STORAGE_CE) {
 721         // CE_n key
 722         auto system_ce_path = android::vold::BuildDataSystemCePath(user_id);
 723         auto misc_ce_path = android::vold::BuildDataMiscCePath(user_id);
 724         auto media_ce_path = android::vold::BuildDataMediaCePath(volume_uuid, user_id);
 725         auto user_ce_path = android::vold::BuildDataUserCePath(volume_uuid, user_id);
 726
 727         if (!prepare_dir(system_ce_path, 0770, AID_SYSTEM, AID_SYSTEM)) return false;
 728         if (!prepare_dir(misc_ce_path, 01771, AID_SYSTEM, AID_MISC)) return false;
 729         if (!prepare_dir(media_ce_path, 0770, AID_MEDIA_RW, AID_MEDIA_RW)) return false;
 730         if (!prepare_dir(user_ce_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
 731
 732         // For now, FBE is only supported on internal storage
 733         if (e4crypt_is_native() && volume_uuid == nullptr) {
 734             std::string ce_raw_ref;
 735             if (!lookup_key_ref(s_ce_key_raw_refs, user_id, &ce_raw_ref)) return false;
 736             if (!ensure_policy(ce_raw_ref, system_ce_path)) return false;
 737             if (!ensure_policy(ce_raw_ref, misc_ce_path)) return false;
 738             if (!ensure_policy(ce_raw_ref, media_ce_path)) return false;
 739             if (!ensure_policy(ce_raw_ref, user_ce_path)) return false;
 740         }
 741     }
 742
 743     return true;
 744 }
 745
 746 bool e4crypt_destroy_user_storage(const char* volume_uuid, userid_t user_id, int flags) {
 747     LOG(DEBUG) << "e4crypt_destroy_user_storage for volume " << escape_null(volume_uuid)
 748                << ", user " << user_id << ", flags " << flags;
 749     bool res = true;
 750
 751     if (flags & FLAG_STORAGE_DE) {
 752         // DE_sys key
 753         auto system_legacy_path = android::vold::BuildDataSystemLegacyPath(user_id);
 754         auto misc_legacy_path = android::vold::BuildDataMiscLegacyPath(user_id);
 755         auto profiles_de_path = android::vold::BuildDataProfilesDePath(user_id);
 756         auto foreign_de_path = android::vold::BuildDataProfilesForeignDexDePath(user_id);
 757
 758         // DE_n key
 759         auto system_de_path = android::vold::BuildDataSystemDePath(user_id);
 760         auto misc_de_path = android::vold::BuildDataMiscDePath(user_id);
 761         auto user_de_path = android::vold::BuildDataUserDePath(volume_uuid, user_id);
 762
 763         if (volume_uuid == nullptr) {
 764             res &= destroy_dir(system_legacy_path);
 765 #if MANAGE_MISC_DIRS
 766             res &= destroy_dir(misc_legacy_path);
 767 #endif
 768             res &= destroy_dir(profiles_de_path);
 769             res &= destroy_dir(foreign_de_path);
 770             res &= destroy_dir(system_de_path);
 771             res &= destroy_dir(misc_de_path);
 772         }
 773         res &= destroy_dir(user_de_path);
 774     }
 775
 776     if (flags & FLAG_STORAGE_CE) {
 777         // CE_n key
 778         auto system_ce_path = android::vold::BuildDataSystemCePath(user_id);
 779         auto misc_ce_path = android::vold::BuildDataMiscCePath(user_id);
 780         auto media_ce_path = android::vold::BuildDataMediaCePath(volume_uuid, user_id);
 781         auto user_ce_path = android::vold::BuildDataUserCePath(volume_uuid, user_id);
 782
 783         if (volume_uuid == nullptr) {
 784             res &= destroy_dir(system_ce_path);
 785             res &= destroy_dir(misc_ce_path);
 786         }
 787         res &= destroy_dir(media_ce_path);
 788         res &= destroy_dir(user_ce_path);
 789     }
 790
 791     return res;
 792 }