381 lines
14 KiB
C++
381 lines
14 KiB
C++
/*
|
|
* Copyright (C) 2016 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "EncryptInplace.h"
|
|
|
|
#include <ext4_utils/ext4.h>
|
|
#include <ext4_utils/ext4_utils.h>
|
|
#include <f2fs_sparseblock.h>
|
|
#include <fcntl.h>
|
|
#include <time.h>
|
|
|
|
#include <algorithm>
|
|
#include <vector>
|
|
|
|
#include <android-base/logging.h>
|
|
#include <android-base/properties.h>
|
|
#include <android-base/unique_fd.h>
|
|
|
|
enum EncryptInPlaceError {
|
|
kSuccess,
|
|
kFailed,
|
|
kFilesystemNotFound,
|
|
};
|
|
|
|
static uint64_t round_up(uint64_t val, size_t amount) {
|
|
if (val % amount) val += amount - (val % amount);
|
|
return val;
|
|
}
|
|
|
|
class InPlaceEncrypter {
|
|
public:
|
|
bool EncryptInPlace(const std::string& crypto_blkdev, const std::string& real_blkdev,
|
|
uint64_t nr_sec, bool set_progress_properties);
|
|
bool ProcessUsedBlock(uint64_t block_num);
|
|
|
|
private:
|
|
// aligned 32K writes tends to make flash happy.
|
|
// SD card association recommends it.
|
|
static const size_t kIOBufferSize = 32768;
|
|
|
|
// Avoid spamming the logs. Print the "Encrypting blocks" log message once
|
|
// every 10000 blocks (which is usually every 40 MB or so), and once at the end.
|
|
static const int kLogInterval = 10000;
|
|
|
|
std::string DescribeFilesystem();
|
|
void InitFs(const std::string& fs_type, uint64_t blocks_to_encrypt, uint64_t total_blocks,
|
|
unsigned int block_size);
|
|
void UpdateProgress(size_t blocks, bool done);
|
|
bool EncryptPendingData();
|
|
bool DoEncryptInPlace();
|
|
|
|
// ext4 methods
|
|
bool ReadExt4BlockBitmap(uint32_t group, uint8_t* buf);
|
|
uint64_t FirstBlockInGroup(uint32_t group);
|
|
uint32_t NumBlocksInGroup(uint32_t group);
|
|
uint32_t NumBaseMetaBlocksInGroup(uint64_t group);
|
|
EncryptInPlaceError EncryptInPlaceExt4();
|
|
|
|
// f2fs methods
|
|
EncryptInPlaceError EncryptInPlaceF2fs();
|
|
|
|
std::string real_blkdev_;
|
|
std::string crypto_blkdev_;
|
|
uint64_t nr_sec_;
|
|
bool set_progress_properties_;
|
|
|
|
android::base::unique_fd realfd_;
|
|
android::base::unique_fd cryptofd_;
|
|
|
|
time_t time_started_;
|
|
int remaining_time_;
|
|
|
|
std::string fs_type_;
|
|
uint64_t blocks_done_;
|
|
uint64_t blocks_to_encrypt_;
|
|
unsigned int block_size_;
|
|
unsigned int cur_pct_;
|
|
|
|
std::vector<uint8_t> io_buffer_;
|
|
uint64_t first_pending_block_;
|
|
size_t blocks_pending_;
|
|
};
|
|
|
|
std::string InPlaceEncrypter::DescribeFilesystem() {
|
|
if (fs_type_.empty())
|
|
return "full block device " + real_blkdev_;
|
|
else
|
|
return fs_type_ + " filesystem on " + real_blkdev_;
|
|
}
|
|
|
|
// Finishes initializing the encrypter, now that the filesystem details are known.
|
|
void InPlaceEncrypter::InitFs(const std::string& fs_type, uint64_t blocks_to_encrypt,
|
|
uint64_t total_blocks, unsigned int block_size) {
|
|
fs_type_ = fs_type;
|
|
blocks_done_ = 0;
|
|
blocks_to_encrypt_ = blocks_to_encrypt;
|
|
block_size_ = block_size;
|
|
cur_pct_ = 0;
|
|
|
|
// Allocate the I/O buffer. kIOBufferSize should always be a multiple of
|
|
// the filesystem block size, but round it up just in case.
|
|
io_buffer_.resize(round_up(kIOBufferSize, block_size));
|
|
first_pending_block_ = 0;
|
|
blocks_pending_ = 0;
|
|
|
|
LOG(INFO) << "Encrypting " << DescribeFilesystem() << " in-place via " << crypto_blkdev_;
|
|
LOG(INFO) << blocks_to_encrypt << " blocks (" << (blocks_to_encrypt * block_size) / 1000000
|
|
<< " MB) of " << total_blocks << " blocks are in-use";
|
|
}
|
|
|
|
void InPlaceEncrypter::UpdateProgress(size_t blocks, bool done) {
|
|
// A log message already got printed for blocks_done_ if one was due, so the
|
|
// next message will be due at the *next* block rounded up to kLogInterval.
|
|
uint64_t blocks_next_msg = round_up(blocks_done_ + 1, kLogInterval);
|
|
|
|
blocks_done_ += blocks;
|
|
|
|
// Ensure that a log message gets printed at the end, but not if one was
|
|
// already printed due to the block count being a multiple of kLogInterval.
|
|
// E.g. we want to show "50000 of 50327" and then "50327 of "50327", but not
|
|
// "50000 of 50000" and then redundantly "50000 of 50000" again.
|
|
if (done && blocks_done_ % kLogInterval != 0) blocks_next_msg = blocks_done_;
|
|
|
|
if (blocks_done_ >= blocks_next_msg)
|
|
LOG(DEBUG) << "Encrypted " << blocks_next_msg << " of " << blocks_to_encrypt_ << " blocks";
|
|
|
|
if (!set_progress_properties_) return;
|
|
|
|
uint64_t new_pct;
|
|
if (done) {
|
|
new_pct = 100;
|
|
} else {
|
|
new_pct = (blocks_done_ * 100) / std::max<uint64_t>(blocks_to_encrypt_, 1);
|
|
new_pct = std::min<uint64_t>(new_pct, 99);
|
|
}
|
|
if (new_pct > cur_pct_) {
|
|
cur_pct_ = new_pct;
|
|
android::base::SetProperty("vold.encrypt_progress", std::to_string(new_pct));
|
|
}
|
|
|
|
if (cur_pct_ >= 5) {
|
|
struct timespec time_now;
|
|
if (clock_gettime(CLOCK_MONOTONIC, &time_now)) {
|
|
PLOG(WARNING) << "Error getting time while updating encryption progress";
|
|
} else {
|
|
double elapsed_time = difftime(time_now.tv_sec, time_started_);
|
|
|
|
uint64_t remaining_blocks = 0;
|
|
if (blocks_done_ < blocks_to_encrypt_)
|
|
remaining_blocks = blocks_to_encrypt_ - blocks_done_;
|
|
|
|
int remaining_time = 0;
|
|
if (blocks_done_ != 0)
|
|
remaining_time = (int)(elapsed_time * remaining_blocks / blocks_done_);
|
|
|
|
// Change time only if not yet set, lower, or a lot higher for
|
|
// best user experience
|
|
if (remaining_time_ == -1 || remaining_time < remaining_time_ ||
|
|
remaining_time > remaining_time_ + 60) {
|
|
remaining_time_ = remaining_time;
|
|
android::base::SetProperty("vold.encrypt_time_remaining",
|
|
std::to_string(remaining_time));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool InPlaceEncrypter::EncryptPendingData() {
|
|
if (blocks_pending_ == 0) return true;
|
|
|
|
ssize_t bytes = blocks_pending_ * block_size_;
|
|
uint64_t offset = first_pending_block_ * block_size_;
|
|
|
|
if (pread64(realfd_, &io_buffer_[0], bytes, offset) != bytes) {
|
|
PLOG(ERROR) << "Error reading real_blkdev " << real_blkdev_ << " for inplace encrypt";
|
|
return false;
|
|
}
|
|
|
|
if (pwrite64(cryptofd_, &io_buffer_[0], bytes, offset) != bytes) {
|
|
PLOG(ERROR) << "Error writing crypto_blkdev " << crypto_blkdev_ << " for inplace encrypt";
|
|
return false;
|
|
}
|
|
|
|
UpdateProgress(blocks_pending_, false);
|
|
|
|
blocks_pending_ = 0;
|
|
return true;
|
|
}
|
|
|
|
bool InPlaceEncrypter::ProcessUsedBlock(uint64_t block_num) {
|
|
// Flush if the amount of pending data has reached the I/O buffer size, if
|
|
// there's a gap between the pending blocks and the next block (due to
|
|
// block(s) not being used by the filesystem and thus not needing
|
|
// encryption), or if the next block will be aligned to the I/O buffer size.
|
|
if (blocks_pending_ * block_size_ == io_buffer_.size() ||
|
|
block_num != first_pending_block_ + blocks_pending_ ||
|
|
(block_num * block_size_) % io_buffer_.size() == 0) {
|
|
if (!EncryptPendingData()) return false;
|
|
first_pending_block_ = block_num;
|
|
}
|
|
blocks_pending_++;
|
|
return true;
|
|
}
|
|
|
|
// Reads the block bitmap for block group |group| into |buf|.
|
|
bool InPlaceEncrypter::ReadExt4BlockBitmap(uint32_t group, uint8_t* buf) {
|
|
uint64_t offset = (uint64_t)aux_info.bg_desc[group].bg_block_bitmap * info.block_size;
|
|
if (pread64(realfd_, buf, info.block_size, offset) != (ssize_t)info.block_size) {
|
|
PLOG(ERROR) << "Failed to read block bitmap for block group " << group;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
uint64_t InPlaceEncrypter::FirstBlockInGroup(uint32_t group) {
|
|
return aux_info.first_data_block + (group * (uint64_t)info.blocks_per_group);
|
|
}
|
|
|
|
uint32_t InPlaceEncrypter::NumBlocksInGroup(uint32_t group) {
|
|
uint64_t remaining = aux_info.len_blocks - FirstBlockInGroup(group);
|
|
return std::min<uint64_t>(info.blocks_per_group, remaining);
|
|
}
|
|
|
|
// In block groups with an uninitialized block bitmap, we only need to encrypt
|
|
// the backup superblock and the block group descriptors (if they are present).
|
|
uint32_t InPlaceEncrypter::NumBaseMetaBlocksInGroup(uint64_t group) {
|
|
if (!ext4_bg_has_super_block(group)) return 0;
|
|
return 1 + aux_info.bg_desc_blocks;
|
|
}
|
|
|
|
EncryptInPlaceError InPlaceEncrypter::EncryptInPlaceExt4() {
|
|
if (setjmp(setjmp_env)) // NOLINT
|
|
return kFilesystemNotFound;
|
|
|
|
if (read_ext(realfd_, 0) != 0) return kFilesystemNotFound;
|
|
|
|
LOG(DEBUG) << "ext4 filesystem has " << aux_info.groups << " block groups";
|
|
|
|
uint64_t blocks_to_encrypt = 0;
|
|
for (uint32_t group = 0; group < aux_info.groups; group++) {
|
|
if (aux_info.bg_desc[group].bg_flags & EXT4_BG_BLOCK_UNINIT)
|
|
blocks_to_encrypt += NumBaseMetaBlocksInGroup(group);
|
|
else
|
|
blocks_to_encrypt +=
|
|
(NumBlocksInGroup(group) - aux_info.bg_desc[group].bg_free_blocks_count);
|
|
}
|
|
|
|
InitFs("ext4", blocks_to_encrypt, aux_info.len_blocks, info.block_size);
|
|
|
|
// Encrypt each block group.
|
|
std::vector<uint8_t> block_bitmap(info.block_size);
|
|
for (uint32_t group = 0; group < aux_info.groups; group++) {
|
|
if (!ReadExt4BlockBitmap(group, &block_bitmap[0])) return kFailed;
|
|
|
|
uint64_t first_block_num = FirstBlockInGroup(group);
|
|
bool uninit = (aux_info.bg_desc[group].bg_flags & EXT4_BG_BLOCK_UNINIT);
|
|
uint32_t block_count = uninit ? NumBaseMetaBlocksInGroup(group) : NumBlocksInGroup(group);
|
|
|
|
// Encrypt each used block in the block group.
|
|
for (uint32_t i = 0; i < block_count; i++) {
|
|
if (uninit || bitmap_get_bit(&block_bitmap[0], i))
|
|
ProcessUsedBlock(first_block_num + i);
|
|
}
|
|
}
|
|
return kSuccess;
|
|
}
|
|
|
|
static int encrypt_f2fs_block(uint64_t block_num, void* _encrypter) {
|
|
InPlaceEncrypter* encrypter = reinterpret_cast<InPlaceEncrypter*>(_encrypter);
|
|
if (!encrypter->ProcessUsedBlock(block_num)) return -1;
|
|
return 0;
|
|
}
|
|
|
|
EncryptInPlaceError InPlaceEncrypter::EncryptInPlaceF2fs() {
|
|
std::unique_ptr<struct f2fs_info, void (*)(struct f2fs_info*)> fs_info(
|
|
generate_f2fs_info(realfd_), free_f2fs_info);
|
|
if (!fs_info) return kFilesystemNotFound;
|
|
|
|
InitFs("f2fs", get_num_blocks_used(fs_info.get()), fs_info->total_blocks, fs_info->block_size);
|
|
if (run_on_used_blocks(0, fs_info.get(), encrypt_f2fs_block, this) != 0) return kFailed;
|
|
return kSuccess;
|
|
}
|
|
|
|
bool InPlaceEncrypter::DoEncryptInPlace() {
|
|
EncryptInPlaceError rc;
|
|
|
|
rc = EncryptInPlaceExt4();
|
|
if (rc != kFilesystemNotFound) return rc == kSuccess;
|
|
|
|
rc = EncryptInPlaceF2fs();
|
|
if (rc != kFilesystemNotFound) return rc == kSuccess;
|
|
|
|
LOG(WARNING) << "No recognized filesystem found on " << real_blkdev_
|
|
<< ". Falling back to encrypting the full block device.";
|
|
InitFs("", nr_sec_, nr_sec_, 512);
|
|
for (uint64_t i = 0; i < nr_sec_; i++) {
|
|
if (!ProcessUsedBlock(i)) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool InPlaceEncrypter::EncryptInPlace(const std::string& crypto_blkdev,
|
|
const std::string& real_blkdev, uint64_t nr_sec,
|
|
bool set_progress_properties) {
|
|
struct timespec time_started = {0};
|
|
|
|
real_blkdev_ = real_blkdev;
|
|
crypto_blkdev_ = crypto_blkdev;
|
|
nr_sec_ = nr_sec;
|
|
set_progress_properties_ = set_progress_properties;
|
|
|
|
realfd_.reset(open64(real_blkdev.c_str(), O_RDONLY | O_CLOEXEC));
|
|
if (realfd_ < 0) {
|
|
PLOG(ERROR) << "Error opening real_blkdev " << real_blkdev << " for inplace encrypt";
|
|
return false;
|
|
}
|
|
|
|
cryptofd_.reset(open64(crypto_blkdev.c_str(), O_WRONLY | O_CLOEXEC));
|
|
if (cryptofd_ < 0) {
|
|
PLOG(ERROR) << "Error opening crypto_blkdev " << crypto_blkdev << " for inplace encrypt";
|
|
return false;
|
|
}
|
|
|
|
if (clock_gettime(CLOCK_MONOTONIC, &time_started)) {
|
|
PLOG(WARNING) << "Error getting time at start of in-place encryption";
|
|
// Note - continue anyway - we'll run with 0
|
|
}
|
|
time_started_ = time_started.tv_sec;
|
|
remaining_time_ = -1;
|
|
|
|
bool success = DoEncryptInPlace();
|
|
|
|
if (success) success &= EncryptPendingData();
|
|
|
|
if (success && fsync(cryptofd_) != 0) {
|
|
PLOG(ERROR) << "Error syncing " << crypto_blkdev_;
|
|
success = false;
|
|
}
|
|
|
|
if (!success) {
|
|
LOG(ERROR) << "In-place encryption of " << DescribeFilesystem() << " failed";
|
|
return false;
|
|
}
|
|
if (blocks_done_ != blocks_to_encrypt_) {
|
|
LOG(WARNING) << "blocks_to_encrypt (" << blocks_to_encrypt_
|
|
<< ") was incorrect; we actually encrypted " << blocks_done_
|
|
<< " blocks. Encryption progress was inaccurate";
|
|
}
|
|
// Make sure vold.encrypt_progress gets set to 100.
|
|
UpdateProgress(0, true);
|
|
LOG(INFO) << "Successfully encrypted " << DescribeFilesystem();
|
|
return true;
|
|
}
|
|
|
|
// Encrypts |real_blkdev| in-place by reading the data from |real_blkdev| and
|
|
// writing it to |crypto_blkdev|, which should be a dm-crypt or dm-default-key
|
|
// device backed by |real_blkdev|. The size to encrypt is |nr_sec| 512-byte
|
|
// sectors; however, if a filesystem is detected, then its size will be used
|
|
// instead, and only the in-use blocks of the filesystem will be encrypted.
|
|
bool encrypt_inplace(const std::string& crypto_blkdev, const std::string& real_blkdev,
|
|
uint64_t nr_sec, bool set_progress_properties) {
|
|
LOG(DEBUG) << "encrypt_inplace(" << crypto_blkdev << ", " << real_blkdev << ", " << nr_sec
|
|
<< ", " << (set_progress_properties ? "true" : "false") << ")";
|
|
|
|
InPlaceEncrypter encrypter;
|
|
return encrypter.EncryptInPlace(crypto_blkdev, real_blkdev, nr_sec, set_progress_properties);
|
|
}
|