Merge "Add disk for StubVolume"
diff --git a/FsCrypt.cpp b/FsCrypt.cpp
index 1f7faac..0619fba 100644
--- a/FsCrypt.cpp
+++ b/FsCrypt.cpp
@@ -62,8 +62,11 @@
using android::base::StringPrintf;
using android::fs_mgr::GetEntryForMountPoint;
using android::vold::BuildDataPath;
+using android::vold::IsFilesystemSupported;
using android::vold::kEmptyAuthentication;
using android::vold::KeyBuffer;
+using android::vold::SetQuotaInherit;
+using android::vold::SetQuotaProjectId;
using android::vold::writeStringToFile;
using namespace android::fscrypt;
@@ -208,6 +211,19 @@
return true;
}
+static bool install_storage_key(const std::string& mountpoint, const EncryptionOptions& options,
+ const KeyBuffer& key, EncryptionPolicy* policy) {
+ KeyBuffer ephemeral_wrapped_key;
+ if (options.use_hw_wrapped_key) {
+ if (!exportWrappedStorageKey(key, &ephemeral_wrapped_key)) {
+ LOG(ERROR) << "Failed to get ephemeral wrapped key";
+ return false;
+ }
+ }
+ return installKey(mountpoint, options, options.use_hw_wrapped_key ? ephemeral_wrapped_key : key,
+ policy);
+}
+
// Retrieve the options to use for encryption policies on adoptable storage.
static bool get_volume_file_encryption_options(EncryptionOptions* options) {
auto contents_mode =
@@ -231,7 +247,7 @@
KeyBuffer ce_key;
if (!read_and_fixate_user_ce_key(user_id, auth, &ce_key)) return false;
EncryptionPolicy ce_policy;
- if (!installKey(DATA_MNT_POINT, options, ce_key, &ce_policy)) return false;
+ if (!install_storage_key(DATA_MNT_POINT, options, ce_key, &ce_policy)) return false;
s_ce_policies[user_id] = ce_policy;
LOG(DEBUG) << "Installed ce key for user " << user_id;
return true;
@@ -261,8 +277,8 @@
EncryptionOptions options;
if (!get_data_file_encryption_options(&options)) return false;
KeyBuffer de_key, ce_key;
- if (!android::vold::randomKey(&de_key)) return false;
- if (!android::vold::randomKey(&ce_key)) return false;
+ if (!generateStorageKey(options, &de_key)) return false;
+ if (!generateStorageKey(options, &ce_key)) return false;
if (create_ephemeral) {
// If the key should be created as ephemeral, don't store it.
s_ephemeral_users.insert(user_id);
@@ -282,10 +298,10 @@
return false;
}
EncryptionPolicy de_policy;
- if (!installKey(DATA_MNT_POINT, options, de_key, &de_policy)) return false;
+ if (!install_storage_key(DATA_MNT_POINT, options, de_key, &de_policy)) return false;
s_de_policies[user_id] = de_policy;
EncryptionPolicy ce_policy;
- if (!installKey(DATA_MNT_POINT, options, ce_key, &ce_policy)) return false;
+ if (!install_storage_key(DATA_MNT_POINT, options, ce_key, &ce_policy)) return false;
s_ce_policies[user_id] = ce_policy;
LOG(DEBUG) << "Created keys for user " << user_id;
return true;
@@ -338,7 +354,7 @@
KeyBuffer de_key;
if (!android::vold::retrieveKey(key_path, kEmptyAuthentication, &de_key)) return false;
EncryptionPolicy de_policy;
- if (!installKey(DATA_MNT_POINT, options, de_key, &de_policy)) return false;
+ if (!install_storage_key(DATA_MNT_POINT, options, de_key, &de_policy)) return false;
s_de_policies[user_id] = de_policy;
LOG(DEBUG) << "Installed de key for user " << user_id;
}
@@ -360,12 +376,11 @@
KeyBuffer device_key;
if (!android::vold::retrieveKey(true, kEmptyAuthentication, device_key_path, device_key_temp,
- &device_key))
+ options, &device_key))
return false;
EncryptionPolicy device_policy;
- if (!android::vold::installKey(DATA_MNT_POINT, options, device_key, &device_policy))
- return false;
+ if (!install_storage_key(DATA_MNT_POINT, options, device_key, &device_policy)) return false;
std::string options_string;
if (!OptionsToString(device_policy.options, &options_string)) {
@@ -380,10 +395,9 @@
LOG(INFO) << "Wrote system DE key reference to:" << ref_filename;
KeyBuffer per_boot_key;
- if (!android::vold::randomKey(&per_boot_key)) return false;
+ if (!generateStorageKey(options, &per_boot_key)) return false;
EncryptionPolicy per_boot_policy;
- if (!android::vold::installKey(DATA_MNT_POINT, options, per_boot_key, &per_boot_policy))
- return false;
+ if (!install_storage_key(DATA_MNT_POINT, options, per_boot_key, &per_boot_policy)) return false;
std::string per_boot_ref_filename = std::string("/data") + fscrypt_key_per_boot_ref;
if (!android::vold::writeStringToFile(per_boot_policy.key_raw_ref, per_boot_ref_filename))
return false;
@@ -590,8 +604,9 @@
EncryptionOptions options;
if (!get_volume_file_encryption_options(&options)) return false;
KeyBuffer key;
- if (!android::vold::retrieveKey(true, auth, key_path, key_path + "_tmp", &key)) return false;
- if (!android::vold::installKey(BuildDataPath(volume_uuid), options, key, policy)) return false;
+ if (!android::vold::retrieveKey(true, auth, key_path, key_path + "_tmp", options, &key))
+ return false;
+ if (!install_storage_key(BuildDataPath(volume_uuid), options, key, policy)) return false;
return true;
}
@@ -783,6 +798,14 @@
if (!prepare_dir(vendor_ce_path, 0771, AID_ROOT, AID_ROOT)) return false;
}
if (!prepare_dir(media_ce_path, 0770, AID_MEDIA_RW, AID_MEDIA_RW)) return false;
+ // Setup quota project ID and inheritance policy
+ if (!IsFilesystemSupported("sdcardfs")) {
+ if (SetQuotaInherit(media_ce_path) != 0) return false;
+ if (SetQuotaProjectId(media_ce_path, multiuser_get_uid(user_id, AID_MEDIA_RW)) != 0) {
+ return false;
+ }
+ }
+
if (!prepare_dir(user_ce_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
if (fscrypt_is_native()) {
diff --git a/KeyStorage.cpp b/KeyStorage.cpp
index dbf190d..a7582c2 100644
--- a/KeyStorage.cpp
+++ b/KeyStorage.cpp
@@ -135,6 +135,30 @@
keymaster.generateKey(paramBuilder, key);
}
+bool generateWrappedStorageKey(KeyBuffer* key) {
+ Keymaster keymaster;
+ if (!keymaster) return false;
+ std::string key_temp;
+ auto paramBuilder = km::AuthorizationSetBuilder().AesEncryptionKey(AES_KEY_BYTES * 8);
+ paramBuilder.Authorization(km::TAG_ROLLBACK_RESISTANCE);
+ paramBuilder.Authorization(km::TAG_STORAGE_KEY);
+ if (!keymaster.generateKey(paramBuilder, &key_temp)) return false;
+ *key = KeyBuffer(key_temp.size());
+ memcpy(reinterpret_cast<void*>(key->data()), key_temp.c_str(), key->size());
+ return true;
+}
+
+bool exportWrappedStorageKey(const KeyBuffer& kmKey, KeyBuffer* key) {
+ Keymaster keymaster;
+ if (!keymaster) return false;
+ std::string key_temp;
+
+ if (!keymaster.exportKey(kmKey, &key_temp)) return false;
+ *key = KeyBuffer(key_temp.size());
+ memcpy(reinterpret_cast<void*>(key->data()), key_temp.c_str(), key->size());
+ return true;
+}
+
static std::pair<km::AuthorizationSet, km::HardwareAuthToken> beginParams(
const KeyAuthentication& auth, const std::string& appId) {
auto paramBuilder = km::AuthorizationSetBuilder()
diff --git a/KeyStorage.h b/KeyStorage.h
index 276b6b9..f9d3ec6 100644
--- a/KeyStorage.h
+++ b/KeyStorage.h
@@ -68,6 +68,11 @@
bool destroyKey(const std::string& dir);
bool runSecdiscardSingle(const std::string& file);
+
+// Generate wrapped storage key using keymaster. Uses STORAGE_KEY tag in keymaster.
+bool generateWrappedStorageKey(KeyBuffer* key);
+// Export the per-boot boot wrapped storage key using keymaster.
+bool exportWrappedStorageKey(const KeyBuffer& kmKey, KeyBuffer* key);
} // namespace vold
} // namespace android
diff --git a/KeyUtil.cpp b/KeyUtil.cpp
index d4a653b..ae4d70b 100644
--- a/KeyUtil.cpp
+++ b/KeyUtil.cpp
@@ -29,6 +29,7 @@
#include <android-base/logging.h>
#include <keyutils.h>
+#include <fscrypt_uapi.h>
#include "KeyStorage.h"
#include "Utils.h"
@@ -45,6 +46,13 @@
return true;
}
+bool generateStorageKey(const EncryptionOptions& options, KeyBuffer* key) {
+ if (options.use_hw_wrapped_key) {
+ return generateWrappedStorageKey(key);
+ }
+ return randomKey(key);
+}
+
// Return true if the kernel supports the ioctls to add/remove fscrypt keys
// directly to/from the filesystem.
bool isFsKeyringSupported(void) {
@@ -222,6 +230,7 @@
return false;
}
+ if (options.use_hw_wrapped_key) arg->flags |= FSCRYPT_ADD_KEY_FLAG_WRAPPED;
// Provide the raw key.
arg->raw_size = key.size();
memcpy(arg->raw, key.data(), key.size());
@@ -307,8 +316,8 @@
}
bool retrieveKey(bool create_if_absent, const KeyAuthentication& key_authentication,
- const std::string& key_path, const std::string& tmp_path, KeyBuffer* key,
- bool keepOld) {
+ const std::string& key_path, const std::string& tmp_path,
+ const EncryptionOptions& options, KeyBuffer* key, bool keepOld) {
if (pathExists(key_path)) {
LOG(DEBUG) << "Key exists, using: " << key_path;
if (!retrieveKey(key_path, key_authentication, key, keepOld)) return false;
@@ -318,7 +327,7 @@
return false;
}
LOG(INFO) << "Creating new key in " << key_path;
- if (!randomKey(key)) return false;
+ if (!generateStorageKey(options, key)) return false;
if (!storeKeyAtomically(key_path, tmp_path, key_authentication, *key)) return false;
}
return true;
diff --git a/KeyUtil.h b/KeyUtil.h
index be5a2ed..878b4ab 100644
--- a/KeyUtil.h
+++ b/KeyUtil.h
@@ -32,6 +32,8 @@
bool randomKey(KeyBuffer* key);
+bool generateStorageKey(const EncryptionOptions& options, KeyBuffer* key);
+
bool isFsKeyringSupported(void);
// Install a file-based encryption key to the kernel, for use by encrypted files
@@ -57,8 +59,8 @@
bool evictKey(const std::string& mountpoint, const EncryptionPolicy& policy);
bool retrieveKey(bool create_if_absent, const KeyAuthentication& key_authentication,
- const std::string& key_path, const std::string& tmp_path, KeyBuffer* key,
- bool keepOld = true);
+ const std::string& key_path, const std::string& tmp_path,
+ const EncryptionOptions& options, KeyBuffer* key, bool keepOld = true);
} // namespace vold
} // namespace android
diff --git a/Keymaster.cpp b/Keymaster.cpp
index a3853f9..c3f2912 100644
--- a/Keymaster.cpp
+++ b/Keymaster.cpp
@@ -138,6 +138,27 @@
return true;
}
+bool Keymaster::exportKey(const KeyBuffer& kmKey, std::string* key) {
+ auto kmKeyBlob = km::support::blob2hidlVec(std::string(kmKey.data(), kmKey.size()));
+ km::ErrorCode km_error;
+ auto hidlCb = [&](km::ErrorCode ret, const hidl_vec<uint8_t>& exportedKeyBlob) {
+ km_error = ret;
+ if (km_error != km::ErrorCode::OK) return;
+ if (key)
+ key->assign(reinterpret_cast<const char*>(&exportedKeyBlob[0]), exportedKeyBlob.size());
+ };
+ auto error = mDevice->exportKey(km::KeyFormat::RAW, kmKeyBlob, {}, {}, hidlCb);
+ if (!error.isOk()) {
+ LOG(ERROR) << "export_key failed: " << error.description();
+ return false;
+ }
+ if (km_error != km::ErrorCode::OK) {
+ LOG(ERROR) << "export_key failed, code " << int32_t(km_error);
+ return false;
+ }
+ return true;
+}
+
bool Keymaster::deleteKey(const std::string& key) {
auto keyBlob = km::support::blob2hidlVec(key);
auto error = mDevice->deleteKey(keyBlob);
@@ -207,6 +228,17 @@
return mDevice->halVersion().securityLevel != km::SecurityLevel::SOFTWARE;
}
+void Keymaster::earlyBootEnded() {
+ auto error = mDevice->earlyBootEnded();
+ if (!error.isOk()) {
+ LOG(ERROR) << "earlyBootEnded failed: " << error.description();
+ }
+ km::V4_1_ErrorCode km_error = error;
+ if (km_error != km::V4_1_ErrorCode::OK && km_error != km::V4_1_ErrorCode::UNIMPLEMENTED) {
+ LOG(ERROR) << "Error reporting early boot ending to keymaster: " << int32_t(km_error);
+ }
+}
+
} // namespace vold
} // namespace android
diff --git a/Keymaster.h b/Keymaster.h
index 049a741..4a9ed02 100644
--- a/Keymaster.h
+++ b/Keymaster.h
@@ -39,6 +39,7 @@
// dangerous thing to rely on, but in this case its implications are simple and straightforward:
// km::ErrorCode refers to the 4.0 ErrorCode, though we pull everything else from 4.1.
using ErrorCode = ::android::hardware::keymaster::V4_0::ErrorCode;
+using V4_1_ErrorCode = ::android::hardware::keymaster::V4_1::ErrorCode;
} // namespace km
@@ -113,6 +114,8 @@
explicit operator bool() { return mDevice.get() != nullptr; }
// Generate a key in the keymaster from the given params.
bool generateKey(const km::AuthorizationSet& inParams, std::string* key);
+ // Exports a keymaster key with STORAGE_KEY tag wrapped with a per-boot ephemeral key
+ bool exportKey(const KeyBuffer& kmKey, std::string* key);
// If the keymaster supports it, permanently delete a key.
bool deleteKey(const std::string& key);
// Replace stored key blob in response to KM_ERROR_KEY_REQUIRES_UPGRADE.
@@ -125,6 +128,10 @@
km::AuthorizationSet* outParams);
bool isSecure();
+ // Tell Keymaster that early boot has ended and early boot-only keys can no longer be created or
+ // used.
+ void earlyBootEnded();
+
private:
sp<KmDevice> mDevice;
DISALLOW_COPY_AND_ASSIGN(Keymaster);
diff --git a/MetadataCrypt.cpp b/MetadataCrypt.cpp
index 088960e..76ea9eb 100644
--- a/MetadataCrypt.cpp
+++ b/MetadataCrypt.cpp
@@ -56,6 +56,14 @@
static const char* kFn_keymaster_key_blob_upgraded = "keymaster_key_blob_upgraded";
static bool mount_via_fs_mgr(const char* mount_point, const char* blk_device) {
+ // We're about to mount data not verified by verified boot. Tell Keymaster that early boot has
+ // ended.
+ //
+ // TODO(paulcrowley): Make a Keymaster singleton or something, so we don't have to repeatedly
+ // open and initialize the service.
+ ::android::vold::Keymaster keymaster;
+ keymaster.earlyBootEnded();
+
// fs_mgr_do_mount runs fsck. Use setexeccon to run trusted
// partitions in the fsck domain.
if (setexeccon(android::vold::sFsckContext)) {
@@ -105,6 +113,23 @@
LOG(INFO) << "Old Key deleted: " << dir;
}
+static bool retrieveMetadataKey(bool create_if_absent, const std::string& key_path,
+ const std::string& tmp_path, KeyBuffer* key, bool keepOld) {
+ if (pathExists(key_path)) {
+ LOG(DEBUG) << "Key exists, using: " << key_path;
+ if (!retrieveKey(key_path, kEmptyAuthentication, key, keepOld)) return false;
+ } else {
+ if (!create_if_absent) {
+ LOG(ERROR) << "No key found in " << key_path;
+ return false;
+ }
+ LOG(INFO) << "Creating new key in " << key_path;
+ if (!randomKey(key)) return false;
+ if (!storeKeyAtomically(key_path, tmp_path, kEmptyAuthentication, *key)) return false;
+ }
+ return true;
+}
+
static bool read_key(const FstabEntry& data_rec, bool create_if_absent, KeyBuffer* key) {
if (data_rec.metadata_key_dir.empty()) {
LOG(ERROR) << "Failed to get metadata_key_dir";
@@ -135,9 +160,7 @@
unlink(newKeyPath.c_str());
}
bool needs_cp = cp_needsCheckpoint();
- if (!android::vold::retrieveKey(create_if_absent, kEmptyAuthentication, dir, temp, key,
- needs_cp))
- return false;
+ if (!retrieveMetadataKey(create_if_absent, dir, temp, key, needs_cp)) return false;
if (needs_cp && pathExists(newKeyPath)) std::thread(commit_key, dir).detach();
return true;
}
diff --git a/TEST_MAPPING b/TEST_MAPPING
new file mode 100644
index 0000000..e1f3653
--- /dev/null
+++ b/TEST_MAPPING
@@ -0,0 +1,10 @@
+{
+ "presubmit": [
+ {
+ "name": "FuseDaemonHostTest"
+ },
+ {
+ "name": "AdoptableHostTest"
+ }
+ ]
+}
diff --git a/Utils.cpp b/Utils.cpp
index 5dde4b0..b31008c 100644
--- a/Utils.cpp
+++ b/Utils.cpp
@@ -33,20 +33,23 @@
#include <dirent.h>
#include <fcntl.h>
#include <linux/fs.h>
+#include <linux/posix_acl.h>
+#include <linux/posix_acl_xattr.h>
#include <mntent.h>
#include <stdio.h>
#include <stdlib.h>
-#include <unistd.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/wait.h>
+#include <sys/xattr.h>
#include <unistd.h>
#include <list>
#include <mutex>
+#include <regex>
#include <thread>
#ifndef UMOUNT_NOFOLLOW
@@ -74,6 +77,11 @@
static const char* kProcFilesystems = "/proc/filesystems";
+static const char* kAndroidDir = "/Android/";
+static const char* kAppDataDir = "/Android/data/";
+static const char* kAppMediaDir = "/Android/media/";
+static const char* kAppObbDir = "/Android/obb/";
+
// Lock used to protect process-level SELinux changes from racing with each
// other between multiple threads.
static std::mutex kSecurityLock;
@@ -116,7 +124,72 @@
}
}
-int SetQuotaProjectId(std::string path, long projectId) {
+// Sets a default ACL where the owner and group can read/write/execute.
+// Other users aren't allowed anything.
+int SetDefault770Acl(const std::string& path, uid_t uid, gid_t gid) {
+ if (IsFilesystemSupported("sdcardfs")) {
+ // sdcardfs magically takes care of this
+ return OK;
+ }
+
+ static constexpr size_t size =
+ sizeof(posix_acl_xattr_header) + 3 * sizeof(posix_acl_xattr_entry);
+ auto buf = std::make_unique<uint8_t[]>(size);
+
+ posix_acl_xattr_header* acl_header = reinterpret_cast<posix_acl_xattr_header*>(buf.get());
+ acl_header->a_version = POSIX_ACL_XATTR_VERSION;
+
+ posix_acl_xattr_entry* entry =
+ reinterpret_cast<posix_acl_xattr_entry*>(buf.get() + sizeof(posix_acl_xattr_header));
+
+ entry[0].e_tag = ACL_USER_OBJ;
+ entry[0].e_perm = ACL_READ | ACL_WRITE | ACL_EXECUTE;
+ entry[0].e_id = uid;
+
+ entry[1].e_tag = ACL_GROUP_OBJ;
+ entry[1].e_perm = ACL_READ | ACL_WRITE | ACL_EXECUTE;
+ entry[1].e_id = gid;
+
+ entry[2].e_tag = ACL_OTHER;
+ entry[2].e_perm = 0;
+ entry[2].e_id = 0;
+
+ int ret = setxattr(path.c_str(), XATTR_NAME_POSIX_ACL_DEFAULT, acl_header, size, 0);
+
+ if (ret != 0) {
+ PLOG(ERROR) << "Failed to set default ACL on " << path;
+ }
+
+ return ret;
+}
+
+int SetQuotaInherit(const std::string& path) {
+ unsigned long flags;
+
+ android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC)));
+ if (fd == -1) {
+ PLOG(ERROR) << "Failed to open " << path << " to set project id inheritance.";
+ return -1;
+ }
+
+ int ret = ioctl(fd, FS_IOC_GETFLAGS, &flags);
+ if (ret == -1) {
+ PLOG(ERROR) << "Failed to get flags for " << path << " to set project id inheritance.";
+ return ret;
+ }
+
+ flags |= FS_PROJINHERIT_FL;
+
+ ret = ioctl(fd, FS_IOC_SETFLAGS, &flags);
+ if (ret == -1) {
+ PLOG(ERROR) << "Failed to set flags for " << path << " to set project id inheritance.";
+ return ret;
+ }
+
+ return 0;
+}
+
+int SetQuotaProjectId(const std::string& path, long projectId) {
struct fsxattr fsx;
android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC)));
@@ -135,46 +208,94 @@
return ioctl(fd, FS_IOC_FSSETXATTR, &fsx);
}
-int PrepareAppDirsFromRoot(std::string path, std::string root, mode_t mode, uid_t uid, gid_t gid) {
- int ret = 0;
- bool isCacheDir = false;
- if (!StartsWith(path, root)) {
- return -1;
+int PrepareDirWithProjectId(const std::string& path, mode_t mode, uid_t uid, gid_t gid,
+ long projectId) {
+ int ret = fs_prepare_dir(path.c_str(), mode, uid, gid);
+
+ if (ret != 0) {
+ return ret;
}
- // Cache directories (eg "/storage/emulated/Android/data/com.foo/cache/") need special treatment
- isCacheDir = EndsWith(root, "/Android/data/") && EndsWith(path, "cache/");
- std::string to_create_from_root = path.substr(root.length());
-
- size_t pos = 0;
- while ((pos = to_create_from_root.find('/')) != std::string::npos) {
- auto component = to_create_from_root.substr(0, pos);
- to_create_from_root.erase(0, pos + 1);
- root = root + component + "/";
- ret = fs_prepare_dir(root.c_str(), mode, uid, gid);
- if (ret) {
- break;
- }
- if (!IsFilesystemSupported("sdcardfs")) {
- long projectId;
- // All app-specific directories share the same project-ID, except
- // the cache directory
- if (isCacheDir && component == "cache") {
- // Note that this also matches paths like:
- // /Android/data/com.foo/bar/cache/
- // This is currently safe because we're never asked to create
- // such directories.
- projectId = uid - AID_APP_START + AID_CACHE_GID_START;
- } else {
- projectId = uid - AID_APP_START + AID_EXT_GID_START;
- }
- ret = SetQuotaProjectId(root, projectId);
- }
+ if (!IsFilesystemSupported("sdcardfs")) {
+ ret = SetQuotaProjectId(path, projectId);
}
return ret;
}
+static gid_t getAppDirGid(const std::string& appDir) {
+ gid_t gid = AID_MEDIA_RW;
+ if (!IsFilesystemSupported("sdcardfs")) {
+ if (appDir == android::vold::kAppDataDir) {
+ gid = AID_EXT_DATA_RW;
+ } else if (appDir == android::vold::kAppObbDir) {
+ gid = AID_EXT_OBB_RW;
+ } else if (appDir == android::vold::kAppMediaDir) {
+ gid = AID_MEDIA_RW;
+ } else {
+ gid = AID_MEDIA_RW;
+ }
+ }
+
+ return gid;
+}
+
+int PrepareAppDirFromRoot(std::string path, int appUid) {
+ int ret = 0;
+ // Extract various parts of the path to setup correctly
+ // Sample path:
+ // /data/media/0/Android/data/com.foo/files
+ // [1]: path in which to create app-specific dir, eg. /data/media/0/Android/data/
+ // [2]: the part of [1] starting from /Android, eg. /Android/data/
+ // [3]: the package name part of the path, eg. com.foo
+ // [4]: the directory to create within [3], eg files
+ std::regex re("(^/.*(/Android/(?:data|media|obb|sandbox)/))([^/]+)/([^/]+)?/?");
+
+ std::smatch match;
+ bool is_match = regex_match(path, match, re);
+
+ if (!is_match) {
+ LOG(ERROR) << "Invalid application directory: " << path;
+ return -EINVAL;
+ }
+
+ uid_t uid = appUid;
+ gid_t gid = getAppDirGid(match.str(2));
+ // mode = 770, plus sticky bit on directory to inherit GID when apps
+ // create subdirs
+ mode_t mode = S_IRWXU | S_IRWXG | S_ISGID;
+ long projectId = uid - AID_APP_START + AID_EXT_GID_START;
+
+ // First, create the package-path
+ std::string package_path = match.str(1) + match.str(3);
+ ret = PrepareDirWithProjectId(package_path, mode, uid, gid, projectId);
+ if (ret) {
+ return ret;
+ }
+
+ // Set the default ACL, to ensure that even if applications run with a
+ // umask of 0077, new directories within these directories will allow the
+ // GID specified here to write; this is necessary for apps like installers
+ // and MTP, that require access here.
+ //
+ // See man (5) acl for more details.
+ ret = SetDefault770Acl(package_path, uid, gid);
+ if (ret) {
+ return ret;
+ }
+
+ // Next, create the directory within the package, if needed
+ if (match.size() <= 4) {
+ return OK;
+ }
+
+ if (match.str(4) == "cache") {
+ // All dirs use the "app" project ID, except for the cache dir
+ projectId = uid - AID_APP_START + AID_CACHE_GID_START;
+ }
+ return PrepareDirWithProjectId(path, mode, uid, gid, projectId);
+}
+
status_t PrepareDir(const std::string& path, mode_t mode, uid_t uid, gid_t gid) {
std::lock_guard<std::mutex> lock(kSecurityLock);
const char* cpath = path.c_str();
diff --git a/Utils.h b/Utils.h
index 90ae8c6..a7dda7a 100644
--- a/Utils.h
+++ b/Utils.h
@@ -36,11 +36,6 @@
static const char* kPropFuse = "persist.sys.fuse";
-static const char* kAndroidDir = "/Android/";
-static const char* kAppDataDir = "/Android/data/";
-static const char* kAppMediaDir = "/Android/media/";
-static const char* kAppObbDir = "/Android/obb/";
-
/* SELinux contexts used depending on the block device type */
extern security_context_t sBlkidContext;
extern security_context_t sBlkidUntrustedContext;
@@ -53,15 +48,16 @@
status_t CreateDeviceNode(const std::string& path, dev_t dev);
status_t DestroyDeviceNode(const std::string& path);
-int SetQuotaProjectId(std::string path, long projectId);
+int SetQuotaInherit(const std::string& path);
+int SetQuotaProjectId(const std::string& path, long projectId);
/*
- * Recursively calls fs_prepare_dir() on all components in 'path', starting at 'root'.
- * 'path' must start with 'root'. Sets up quota project IDs correctly.
+ * Creates and sets up an application-specific path on external
+ * storage with the correct ACL and project ID (if needed).
*
* ONLY for use with app-specific data directories on external storage!
* (eg, /Android/data/com.foo, /Android/obb/com.foo, etc.)
*/
-int PrepareAppDirsFromRoot(std::string path, std::string root, mode_t mode, uid_t uid, gid_t gid);
+int PrepareAppDirFromRoot(std::string path, int appUid);
/* fs_prepare_dir wrapper that creates with SELinux context */
status_t PrepareDir(const std::string& path, mode_t mode, uid_t uid, gid_t gid);
diff --git a/VoldNativeService.cpp b/VoldNativeService.cpp
index d648ebc..6aa9670 100644
--- a/VoldNativeService.cpp
+++ b/VoldNativeService.cpp
@@ -458,14 +458,12 @@
return translate(VolumeManager::Instance()->remountUid(uid, remountMode));
}
-binder::Status VoldNativeService::setupAppDir(const std::string& path,
- const std::string& appDirRoot, int32_t appUid) {
+binder::Status VoldNativeService::setupAppDir(const std::string& path, int32_t appUid) {
ENFORCE_SYSTEM_OR_ROOT;
CHECK_ARGUMENT_PATH(path);
- CHECK_ARGUMENT_PATH(appDirRoot);
ACQUIRE_LOCK;
- return translate(VolumeManager::Instance()->setupAppDir(path, appDirRoot, appUid));
+ return translate(VolumeManager::Instance()->setupAppDir(path, appUid));
}
binder::Status VoldNativeService::createObb(const std::string& sourcePath,
diff --git a/VoldNativeService.h b/VoldNativeService.h
index a276de3..6d00d2d 100644
--- a/VoldNativeService.h
+++ b/VoldNativeService.h
@@ -65,8 +65,7 @@
binder::Status remountUid(int32_t uid, int32_t remountMode);
- binder::Status setupAppDir(const std::string& path, const std::string& appDirRoot,
- int32_t appUid);
+ binder::Status setupAppDir(const std::string& path, int32_t appUid);
binder::Status createObb(const std::string& sourcePath, const std::string& sourceKey,
int32_t ownerGid, std::string* _aidl_return);
diff --git a/VolumeManager.cpp b/VolumeManager.cpp
index 7be5e4f..0c81cb7 100644
--- a/VolumeManager.cpp
+++ b/VolumeManager.cpp
@@ -82,7 +82,7 @@
using android::vold::DeleteDirContentsAndDir;
using android::vold::IsFilesystemSupported;
using android::vold::PrepareAndroidDirs;
-using android::vold::PrepareAppDirsFromRoot;
+using android::vold::PrepareAppDirFromRoot;
using android::vold::PrivateVolume;
using android::vold::Symlink;
using android::vold::Unlink;
@@ -814,31 +814,7 @@
return 0;
}
-static gid_t getAppDirGid(const std::string& appDir) {
- // Create app-specific dirs with the correct UID/GID
- gid_t gid = AID_MEDIA_RW;
- if (!IsFilesystemSupported("sdcardfs")) {
- if (appDir == android::vold::kAppDataDir) {
- gid = AID_EXT_DATA_RW;
- } else if (appDir == android::vold::kAppObbDir) {
- gid = AID_EXT_OBB_RW;
- } else if (appDir == android::vold::kAppMediaDir) {
- gid = AID_MEDIA_RW;
- } else {
- gid = AID_MEDIA_RW;
- }
- }
-
- return gid;
-}
-
-static bool isValidAppDirRoot(const std::string& appDirRoot) {
- return appDirRoot == android::vold::kAppDataDir || appDirRoot == android::vold::kAppMediaDir ||
- appDirRoot == android::vold::kAppObbDir;
-}
-
-int VolumeManager::setupAppDir(const std::string& path, const std::string& appDirRoot,
- int32_t appUid) {
+int VolumeManager::setupAppDir(const std::string& path, int32_t appUid) {
// Only offer to create directories for paths managed by vold
if (!StartsWith(path, "/storage/")) {
LOG(ERROR) << "Failed to find mounted volume for " << path;
@@ -880,19 +856,10 @@
// on /storage/emulated/10 means /mnt/user/0/emulated/10
const std::string lowerPath =
volume->getInternalPath() + path.substr(volume->getPath().length());
- const std::string lowerAppDirRoot =
- volume->getInternalPath() + appDirRoot.substr(volume->getPath().length());
// Do some sanity checking on the app dir (relative from root)
const std::string volumeRoot = volume->getRootPath(); // eg /data/media/0
- // eg, if lowerAppDirRoot = /data/media/0/Android/data, this is /Android/data
- const std::string relativeAppRoot = lowerAppDirRoot.substr(volumeRoot.length());
- if (!isValidAppDirRoot(relativeAppRoot)) {
- LOG(ERROR) << path << " is not a valid application directory.";
- return -EINVAL;
- }
-
// Make sure the Android/ directories exist and are setup correctly
int ret = PrepareAndroidDirs(volumeRoot);
if (ret != 0) {
@@ -900,8 +867,8 @@
return ret;
}
- gid_t gid = getAppDirGid(relativeAppRoot);
- return PrepareAppDirsFromRoot(lowerPath, lowerAppDirRoot, 0770, appUid, gid);
+ // Finally, create the app paths we need
+ return PrepareAppDirFromRoot(lowerPath, appUid);
}
int VolumeManager::createObb(const std::string& sourcePath, const std::string& sourceKey,
diff --git a/VolumeManager.h b/VolumeManager.h
index 992b6dc..765349d 100644
--- a/VolumeManager.h
+++ b/VolumeManager.h
@@ -133,20 +133,27 @@
/*
* Creates a directory 'path' for an application, automatically creating
- * directories along the given path if they don't exist yet. 'appDirRoot'
- * is the "root" directory for app-specific directories of this kind;
- * 'path' must always start with 'appDirRoot'.
+ * directories along the given path if they don't exist yet.
*
* Example:
* path = /storage/emulated/0/Android/data/com.foo/files/
- * appDirRoot = /storage/emulated/0/Android/data/
*
- * This function will set the UID of all app-specific directories below
- * 'appDirRoot' to the 'appUid' argument. In the given example, the UID
+ * This function will first match the first part of the path with the volume
+ * root of any known volumes; in this case, "/storage/emulated/0" matches
+ * with the volume root of the emulated volume for user 0.
+ *
+ * The subseqent part of the path must start with one of the well-known
+ * Android/ data directories, /Android/data, /Android/obb or
+ * /Android/media.
+ *
+ * The final part of the path is application specific. This function will
+ * create all directories, including the application-specific ones, and
+ * set the UID of all app-specific directories below the well-known data
+ * directories to the 'appUid' argument. In the given example, the UID
* of /storage/emulated/0/Android/data/com.foo and
* /storage/emulated/0/Android/data/com.foo/files would be set to 'appUid'.
*
- * The UID of the parent directories will be set according to the
+ * The UID/GID of the parent directories will be set according to the
* requirements of the underlying filesystem and are of no concern to the
* caller.
*
@@ -155,7 +162,7 @@
* and ignored, unless the path ends with "/". Also ensures that path
* belongs to a volume managed by vold.
*/
- int setupAppDir(const std::string& path, const std::string& appDirRoot, int32_t appUid);
+ int setupAppDir(const std::string& path, int32_t appUid);
int createObb(const std::string& path, const std::string& key, int32_t ownerGid,
std::string* outVolId);
diff --git a/binder/android/os/IVold.aidl b/binder/android/os/IVold.aidl
index d4a55c8..78598b3 100644
--- a/binder/android/os/IVold.aidl
+++ b/binder/android/os/IVold.aidl
@@ -54,7 +54,7 @@
void remountUid(int uid, int remountMode);
- void setupAppDir(@utf8InCpp String path, @utf8InCpp String appDirRoot, int appUid);
+ void setupAppDir(@utf8InCpp String path, int appUid);
@utf8InCpp String createObb(@utf8InCpp String sourcePath, @utf8InCpp String sourceKey,
int ownerGid);
diff --git a/cryptfs.cpp b/cryptfs.cpp
index 64b72f0..def306d 100644
--- a/cryptfs.cpp
+++ b/cryptfs.cpp
@@ -64,6 +64,9 @@
#include <time.h>
#include <unistd.h>
+#include <chrono>
+#include <thread>
+
extern "C" {
#include <crypto_scrypt.h>
}
@@ -71,6 +74,7 @@
using android::base::ParseUint;
using android::base::StringPrintf;
using android::fs_mgr::GetEntryForMountPoint;
+using android::vold::KeyBuffer;
using namespace android::dm;
using namespace std::chrono_literals;
@@ -1164,8 +1168,8 @@
}
static int create_crypto_blk_dev(struct crypt_mnt_ftr* crypt_ftr, const unsigned char* master_key,
- const char* real_blk_name, char* crypto_blk_name, const char* name,
- uint32_t flags) {
+ const char* real_blk_name, std::string* crypto_blk_name,
+ const char* name, uint32_t flags) {
auto& dm = DeviceMapper::Instance();
// We need two ASCII characters to represent each byte, and need space for
@@ -1205,15 +1209,13 @@
SLOGI("Took %d tries to load dmcrypt table.\n", load_count);
}
- std::string path;
- if (!dm.GetDmDevicePathByName(name, &path)) {
+ if (!dm.GetDmDevicePathByName(name, crypto_blk_name)) {
SLOGE("Cannot determine dm-crypt path for %s.\n", name);
return -1;
}
- snprintf(crypto_blk_name, MAXPATHLEN, "%s", path.c_str());
/* Ensure the dm device has been created before returning. */
- if (android::vold::WaitForFile(crypto_blk_name, 1s) < 0) {
+ if (android::vold::WaitForFile(crypto_blk_name->c_str(), 1s) < 0) {
// WaitForFile generates a suitable log message
return -1;
}
@@ -1221,9 +1223,22 @@
}
static int delete_crypto_blk_dev(const std::string& name) {
+ bool ret;
auto& dm = DeviceMapper::Instance();
- if (!dm.DeleteDevice(name)) {
- SLOGE("Cannot remove dm-crypt device %s: %s\n", name.c_str(), strerror(errno));
+ // TODO(b/149396179) there appears to be a race somewhere in the system where trying
+ // to delete the device fails with EBUSY; for now, work around this by retrying.
+ int tries = 5;
+ while (tries-- > 0) {
+ ret = dm.DeleteDevice(name);
+ if (ret || errno != EBUSY) {
+ break;
+ }
+ SLOGW("DM_DEV Cannot remove dm-crypt device %s: %s, retrying...\n", name.c_str(),
+ strerror(errno));
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
+ }
+ if (!ret) {
+ SLOGE("DM_DEV Cannot remove dm-crypt device %s: %s\n", name.c_str(), strerror(errno));
return -1;
}
return 0;
@@ -1778,7 +1793,7 @@
static int test_mount_encrypted_fs(struct crypt_mnt_ftr* crypt_ftr, const char* passwd,
const char* mount_point, const char* label) {
unsigned char decrypted_master_key[MAX_KEY_LEN];
- char crypto_blkdev[MAXPATHLEN];
+ std::string crypto_blkdev;
std::string real_blkdev;
char tmp_mount_point[64];
unsigned int orig_failed_decrypt_count;
@@ -1807,7 +1822,7 @@
// Create crypto block device - all (non fatal) code paths
// need it
- if (create_crypto_blk_dev(crypt_ftr, decrypted_master_key, real_blkdev.c_str(), crypto_blkdev,
+ if (create_crypto_blk_dev(crypt_ftr, decrypted_master_key, real_blkdev.c_str(), &crypto_blkdev,
label, 0)) {
SLOGE("Error creating decrypted block device\n");
rc = -1;
@@ -1831,7 +1846,8 @@
* the footer, not the key. */
snprintf(tmp_mount_point, sizeof(tmp_mount_point), "%s/tmp_mnt", mount_point);
mkdir(tmp_mount_point, 0755);
- if (fs_mgr_do_mount(&fstab_default, DATA_MNT_POINT, crypto_blkdev, tmp_mount_point)) {
+ if (fs_mgr_do_mount(&fstab_default, DATA_MNT_POINT,
+ const_cast<char*>(crypto_blkdev.c_str()), tmp_mount_point)) {
SLOGE("Error temp mounting decrypted block device\n");
delete_crypto_blk_dev(label);
@@ -1853,7 +1869,7 @@
/* Save the name of the crypto block device
* so we can mount it when restarting the framework. */
- property_set("ro.crypto.fs_crypto_blkdev", crypto_blkdev);
+ property_set("ro.crypto.fs_crypto_blkdev", crypto_blkdev.c_str());
/* Also save a the master key so we can reencrypted the key
* the key when we want to change the password on it. */
@@ -1910,11 +1926,14 @@
* storage volume. The incoming partition has no crypto header/footer,
* as any metadata is been stored in a separate, small partition. We
* assume it must be using our same crypt type and keysize.
- *
- * out_crypto_blkdev must be MAXPATHLEN.
*/
-int cryptfs_setup_ext_volume(const char* label, const char* real_blkdev, const unsigned char* key,
- char* out_crypto_blkdev) {
+int cryptfs_setup_ext_volume(const char* label, const char* real_blkdev, const KeyBuffer& key,
+ std::string* out_crypto_blkdev) {
+ if (key.size() != cryptfs_get_keysize()) {
+ SLOGE("Raw keysize %zu does not match crypt keysize %" PRIu32, key.size(),
+ cryptfs_get_keysize());
+ return -1;
+ }
uint64_t nr_sec = 0;
if (android::vold::GetBlockDev512Sectors(real_blkdev, &nr_sec) != android::OK) {
SLOGE("Failed to get size of %s: %s", real_blkdev, strerror(errno));
@@ -1932,15 +1951,8 @@
android::base::GetBoolProperty("ro.crypto.allow_encrypt_override", false))
flags |= CREATE_CRYPTO_BLK_DEV_FLAGS_ALLOW_ENCRYPT_OVERRIDE;
- return create_crypto_blk_dev(&ext_crypt_ftr, key, real_blkdev, out_crypto_blkdev, label, flags);
-}
-
-/*
- * Called by vold when it's asked to unmount an encrypted external
- * storage volume.
- */
-int cryptfs_revert_ext_volume(const char* label) {
- return delete_crypto_blk_dev(label);
+ return create_crypto_blk_dev(&ext_crypt_ftr, reinterpret_cast<const unsigned char*>(key.data()),
+ real_blkdev, out_crypto_blkdev, label, flags);
}
int cryptfs_crypto_complete(void) {
@@ -2132,8 +2144,8 @@
return 0;
}
-static int cryptfs_enable_all_volumes(struct crypt_mnt_ftr* crypt_ftr, char* crypto_blkdev,
- char* real_blkdev, int previously_encrypted_upto) {
+static int cryptfs_enable_all_volumes(struct crypt_mnt_ftr* crypt_ftr, const char* crypto_blkdev,
+ const char* real_blkdev, int previously_encrypted_upto) {
off64_t cur_encryption_done = 0, tot_encryption_size = 0;
int rc = -1;
@@ -2168,7 +2180,7 @@
}
int cryptfs_enable_internal(int crypt_type, const char* passwd, int no_ui) {
- char crypto_blkdev[MAXPATHLEN];
+ std::string crypto_blkdev;
std::string real_blkdev;
unsigned char decrypted_master_key[MAX_KEY_LEN];
int rc = -1, i;
@@ -2377,14 +2389,14 @@
}
decrypt_master_key(passwd, decrypted_master_key, &crypt_ftr, 0, 0);
- create_crypto_blk_dev(&crypt_ftr, decrypted_master_key, real_blkdev.c_str(), crypto_blkdev,
+ create_crypto_blk_dev(&crypt_ftr, decrypted_master_key, real_blkdev.c_str(), &crypto_blkdev,
CRYPTO_BLOCK_DEVICE, 0);
/* If we are continuing, check checksums match */
rc = 0;
if (previously_encrypted_upto) {
__le8 hash_first_block[SHA256_DIGEST_LENGTH];
- rc = cryptfs_SHA256_fileblock(crypto_blkdev, hash_first_block);
+ rc = cryptfs_SHA256_fileblock(crypto_blkdev.c_str(), hash_first_block);
if (!rc &&
memcmp(hash_first_block, crypt_ftr.hash_first_block, sizeof(hash_first_block)) != 0) {
@@ -2394,13 +2406,13 @@
}
if (!rc) {
- rc = cryptfs_enable_all_volumes(&crypt_ftr, crypto_blkdev, real_blkdev.data(),
+ rc = cryptfs_enable_all_volumes(&crypt_ftr, crypto_blkdev.c_str(), real_blkdev.data(),
previously_encrypted_upto);
}
/* Calculate checksum if we are not finished */
if (!rc && crypt_ftr.encrypted_upto != crypt_ftr.fs_size) {
- rc = cryptfs_SHA256_fileblock(crypto_blkdev, crypt_ftr.hash_first_block);
+ rc = cryptfs_SHA256_fileblock(crypto_blkdev.c_str(), crypt_ftr.hash_first_block);
if (rc) {
SLOGE("Error calculating checksum for continuing encryption");
rc = -1;
diff --git a/cryptfs.h b/cryptfs.h
index 28d1887..9b5eae7 100644
--- a/cryptfs.h
+++ b/cryptfs.h
@@ -17,12 +17,16 @@
#ifndef ANDROID_VOLD_CRYPTFS_H
#define ANDROID_VOLD_CRYPTFS_H
+#include <string>
+
#include <linux/types.h>
#include <stdbool.h>
#include <stdint.h>
#include <cutils/properties.h>
+#include "KeyBuffer.h"
+
#define CRYPT_FOOTER_OFFSET 0x4000
/* Return values for cryptfs_crypto_complete */
@@ -60,9 +64,8 @@
int cryptfs_enable(int type, const char* passwd, int no_ui);
int cryptfs_changepw(int type, const char* newpw);
int cryptfs_enable_default(int no_ui);
-int cryptfs_setup_ext_volume(const char* label, const char* real_blkdev, const unsigned char* key,
- char* out_crypto_blkdev);
-int cryptfs_revert_ext_volume(const char* label);
+int cryptfs_setup_ext_volume(const char* label, const char* real_blkdev,
+ const android::vold::KeyBuffer& key, std::string* out_crypto_blkdev);
int cryptfs_getfield(const char* fieldname, char* value, int len);
int cryptfs_setfield(const char* fieldname, const char* value);
int cryptfs_mount_default_encrypted(void);
diff --git a/fscrypt_uapi.h b/fscrypt_uapi.h
new file mode 100644
index 0000000..08592e0
--- /dev/null
+++ b/fscrypt_uapi.h
@@ -0,0 +1,19 @@
+#ifndef _UAPI_LINUX_FSCRYPT_VOLD_H
+#define _UAPI_LINUX_FSCRYPT_VOLD_H
+
+#include <linux/fscrypt.h>
+#include <linux/types.h>
+
+#define FSCRYPT_ADD_KEY_FLAG_WRAPPED 0x01
+
+struct sys_fscrypt_add_key_arg {
+ struct fscrypt_key_specifier key_spec;
+ __u32 raw_size;
+ __u32 __reserved[8];
+ __u32 flags;
+ __u8 raw[];
+};
+
+#define fscrypt_add_key_arg sys_fscrypt_add_key_arg
+
+#endif //_UAPI_LINUX_FSCRYPT_VOLD_H
diff --git a/model/Disk.cpp b/model/Disk.cpp
index d08891a..7ecc89e 100644
--- a/model/Disk.cpp
+++ b/model/Disk.cpp
@@ -231,7 +231,8 @@
LOG(DEBUG) << "Found key for GUID " << normalizedGuid;
- auto vol = std::shared_ptr<VolumeBase>(new PrivateVolume(device, keyRaw));
+ auto keyBuffer = KeyBuffer(keyRaw.begin(), keyRaw.end());
+ auto vol = std::shared_ptr<VolumeBase>(new PrivateVolume(device, keyBuffer));
if (mJustPartitioned) {
LOG(DEBUG) << "Device just partitioned; silently formatting";
vol->setSilent(true);
diff --git a/model/PrivateVolume.cpp b/model/PrivateVolume.cpp
index 5098e5d..9f1f089 100644
--- a/model/PrivateVolume.cpp
+++ b/model/PrivateVolume.cpp
@@ -25,6 +25,7 @@
#include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include <cutils/fs.h>
+#include <libdm/dm.h>
#include <private/android_filesystem_config.h>
#include <fcntl.h>
@@ -43,7 +44,7 @@
static const unsigned int kMajorBlockMmc = 179;
-PrivateVolume::PrivateVolume(dev_t device, const std::string& keyRaw)
+PrivateVolume::PrivateVolume(dev_t device, const KeyBuffer& keyRaw)
: VolumeBase(Type::kPrivate), mRawDevice(device), mKeyRaw(keyRaw) {
setId(StringPrintf("private:%u,%u", major(device), minor(device)));
mRawDevPath = StringPrintf("/dev/block/vold/%s", getId().c_str());
@@ -64,21 +65,17 @@
if (CreateDeviceNode(mRawDevPath, mRawDevice)) {
return -EIO;
}
- if (mKeyRaw.size() != cryptfs_get_keysize()) {
- PLOG(ERROR) << getId() << " Raw keysize " << mKeyRaw.size()
- << " does not match crypt keysize " << cryptfs_get_keysize();
+
+ // Recover from stale vold by tearing down any old mappings
+ auto& dm = dm::DeviceMapper::Instance();
+ if (!dm.DeleteDeviceIfExists(getId())) {
+ PLOG(ERROR) << "Cannot remove dm device " << getId();
return -EIO;
}
- // Recover from stale vold by tearing down any old mappings
- cryptfs_revert_ext_volume(getId().c_str());
-
// TODO: figure out better SELinux labels for private volumes
- unsigned char* key = (unsigned char*)mKeyRaw.data();
- char crypto_blkdev[MAXPATHLEN];
- int res = cryptfs_setup_ext_volume(getId().c_str(), mRawDevPath.c_str(), key, crypto_blkdev);
- mDmDevPath = crypto_blkdev;
+ int res = cryptfs_setup_ext_volume(getId().c_str(), mRawDevPath.c_str(), mKeyRaw, &mDmDevPath);
if (res != 0) {
PLOG(ERROR) << getId() << " failed to setup cryptfs";
return -EIO;
@@ -88,8 +85,10 @@
}
status_t PrivateVolume::doDestroy() {
- if (cryptfs_revert_ext_volume(getId().c_str())) {
- LOG(ERROR) << getId() << " failed to revert cryptfs";
+ auto& dm = dm::DeviceMapper::Instance();
+ if (!dm.DeleteDevice(getId())) {
+ PLOG(ERROR) << "Cannot remove dm device " << getId();
+ return -EIO;
}
return DestroyDeviceNode(mRawDevPath);
}
diff --git a/model/PrivateVolume.h b/model/PrivateVolume.h
index 656172f..9780485 100644
--- a/model/PrivateVolume.h
+++ b/model/PrivateVolume.h
@@ -37,7 +37,7 @@
*/
class PrivateVolume : public VolumeBase {
public:
- PrivateVolume(dev_t device, const std::string& keyRaw);
+ PrivateVolume(dev_t device, const KeyBuffer& keyRaw);
virtual ~PrivateVolume();
const std::string& getFsType() const { return mFsType; };
const std::string& getRawDevPath() const { return mRawDevPath; };
@@ -65,7 +65,7 @@
std::string mPath;
/* Encryption key as raw bytes */
- std::string mKeyRaw;
+ KeyBuffer mKeyRaw;
/* Filesystem type */
std::string mFsType;