Merge "Add install/wipe_device.cpp." (a4993ce0) · Commits · e / os / android_bootable_recovery

install/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -66,6 +66,7 @@ cc_library_static {
		"package.cpp",
		"verifier.cpp",
		"wipe_data.cpp",
		"wipe_device.cpp",
		],

		shared_libs: [

install/include/install/install.h

+0 −3

Original line number	Diff line number	Diff line
		@@ -58,9 +58,6 @@ bool verify_package(Package* package, RecoveryUI* ui);
		// result to \|metadata\|. Return true if succeed, otherwise return false.
		bool ReadMetadataFromPackage(ZipArchiveHandle zip, std::map<std::string, std::string>* metadata);

		// Reads the "recovery.wipe" entry in the zip archive returns a list of partitions to wipe.
		std::vector<std::string> GetWipePartitionList(Package* wipe_package);

		// Verifies the compatibility info in a Treble-compatible package. Returns true directly if the
		// entry doesn't exist.
		bool verify_package_compatibility(ZipArchiveHandle package_zip);

install/include/install/wipe_device.h

0 → 100644

+29 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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.
		*/

		#pragma once

		#include <string>
		#include <vector>

		#include "install/package.h"
		#include "recovery_ui/device.h"

		// Wipes the current A/B device, with a secure wipe of all the partitions in RECOVERY_WIPE.
		bool WipeAbDevice(Device* device, size_t wipe_package_size);

		// Reads the "recovery.wipe" entry in the zip archive returns a list of partitions to wipe.
		std::vector<std::string> GetWipePartitionList(Package* wipe_package);

install/wipe_device.cpp

0 → 100644

+198 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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 "install/wipe_device.h"

		#include <errno.h>
		#include <fcntl.h>
		#include <linux/fs.h>
		#include <stdint.h>
		#include <sys/ioctl.h>

		#include <map>
		#include <memory>
		#include <string>
		#include <vector>

		#include <android-base/file.h>
		#include <android-base/logging.h>
		#include <android-base/strings.h>
		#include <android-base/unique_fd.h>
		#include <ziparchive/zip_archive.h>

		#include "bootloader_message/bootloader_message.h"
		#include "install/install.h"
		#include "install/package.h"
		#include "recovery_ui/device.h"
		#include "recovery_ui/ui.h"

		std::vector<std::string> GetWipePartitionList(Package* wipe_package) {
		ZipArchiveHandle zip = wipe_package->GetZipArchiveHandle();
		if (!zip) {
		LOG(ERROR) << "Failed to get ZipArchiveHandle";
		return {};
		}

		constexpr char RECOVERY_WIPE_ENTRY_NAME[] = "recovery.wipe";

		std::string partition_list_content;
		ZipString path(RECOVERY_WIPE_ENTRY_NAME);
		ZipEntry entry;
		if (FindEntry(zip, path, &entry) == 0) {
		uint32_t length = entry.uncompressed_length;
		partition_list_content = std::string(length, '\0');
		if (auto err = ExtractToMemory(
		zip, &entry, reinterpret_cast<uint8_t*>(partition_list_content.data()), length);
		err != 0) {
		LOG(ERROR) << "Failed to extract " << RECOVERY_WIPE_ENTRY_NAME << ": "
		<< ErrorCodeString(err);
		return {};
		}
		} else {
		LOG(INFO) << "Failed to find " << RECOVERY_WIPE_ENTRY_NAME
		<< ", falling back to use the partition list on device.";

		constexpr char RECOVERY_WIPE_ON_DEVICE[] = "/etc/recovery.wipe";
		if (!android::base::ReadFileToString(RECOVERY_WIPE_ON_DEVICE, &partition_list_content)) {
		PLOG(ERROR) << "failed to read \"" << RECOVERY_WIPE_ON_DEVICE << "\"";
		return {};
		}
		}

		std::vector<std::string> result;
		auto lines = android::base::Split(partition_list_content, "\n");
		for (const auto& line : lines) {
		auto partition = android::base::Trim(line);
		// Ignore '#' comment or empty lines.
		if (android::base::StartsWith(partition, "#") \|\| partition.empty()) {
		continue;
		}
		result.push_back(line);
		}

		return result;
		}

		// Secure-wipes a given partition. It uses BLKSECDISCARD, if supported. Otherwise, it goes with
		// BLKDISCARD (if device supports BLKDISCARDZEROES) or BLKZEROOUT.
		static bool SecureWipePartition(const std::string& partition) {
		android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(partition.c_str(), O_WRONLY)));
		if (fd == -1) {
		PLOG(ERROR) << "Failed to open \"" << partition << "\"";
		return false;
		}

		uint64_t range[2] = { 0, 0 };
		if (ioctl(fd, BLKGETSIZE64, &range[1]) == -1 \|\| range[1] == 0) {
		PLOG(ERROR) << "Failed to get partition size";
		return false;
		}
		LOG(INFO) << "Secure-wiping \"" << partition << "\" from " << range[0] << " to " << range[1];

		LOG(INFO) << " Trying BLKSECDISCARD...";
		if (ioctl(fd, BLKSECDISCARD, &range) == -1) {
		PLOG(WARNING) << " Failed";

		// Use BLKDISCARD if it zeroes out blocks, otherwise use BLKZEROOUT.
		unsigned int zeroes;
		if (ioctl(fd, BLKDISCARDZEROES, &zeroes) == 0 && zeroes != 0) {
		LOG(INFO) << " Trying BLKDISCARD...";
		if (ioctl(fd, BLKDISCARD, &range) == -1) {
		PLOG(ERROR) << " Failed";
		return false;
		}
		} else {
		LOG(INFO) << " Trying BLKZEROOUT...";
		if (ioctl(fd, BLKZEROOUT, &range) == -1) {
		PLOG(ERROR) << " Failed";
		return false;
		}
		}
		}

		LOG(INFO) << " Done";
		return true;
		}

		static std::unique_ptr<Package> ReadWipePackage(size_t wipe_package_size) {
		if (wipe_package_size == 0) {
		LOG(ERROR) << "wipe_package_size is zero";
		return nullptr;
		}

		std::string wipe_package;
		if (std::string err_str; !read_wipe_package(&wipe_package, wipe_package_size, &err_str)) {
		PLOG(ERROR) << "Failed to read wipe package" << err_str;
		return nullptr;
		}

		return Package::CreateMemoryPackage(
		std::vector<uint8_t>(wipe_package.begin(), wipe_package.end()), nullptr);
		}

		// Checks if the wipe package matches expectation. If the check passes, reads the list of
		// partitions to wipe from the package. Checks include
		// 1. verify the package.
		// 2. check metadata (ota-type, pre-device and serial number if having one).
		static bool CheckWipePackage(Package* wipe_package, RecoveryUI* ui) {
		if (!verify_package(wipe_package, ui)) {
		LOG(ERROR) << "Failed to verify package";
		return false;
		}

		ZipArchiveHandle zip = wipe_package->GetZipArchiveHandle();
		if (!zip) {
		LOG(ERROR) << "Failed to get ZipArchiveHandle";
		return false;
		}

		std::map<std::string, std::string> metadata;
		if (!ReadMetadataFromPackage(zip, &metadata)) {
		LOG(ERROR) << "Failed to parse metadata in the zip file";
		return false;
		}

		return CheckPackageMetadata(metadata, OtaType::BRICK) == 0;
		}

		bool WipeAbDevice(Device* device, size_t wipe_package_size) {
		auto ui = device->GetUI();
		ui->SetBackground(RecoveryUI::ERASING);
		ui->SetProgressType(RecoveryUI::INDETERMINATE);

		auto wipe_package = ReadWipePackage(wipe_package_size);
		if (!wipe_package) {
		LOG(ERROR) << "Failed to open wipe package";
		return false;
		}

		if (!CheckWipePackage(wipe_package.get(), ui)) {
		LOG(ERROR) << "Failed to verify wipe package";
		return false;
		}

		auto partition_list = GetWipePartitionList(wipe_package.get());
		if (partition_list.empty()) {
		LOG(ERROR) << "Empty wipe ab partition list";
		return false;
		}

		for (const auto& partition : partition_list) {
		// Proceed anyway even if it fails to wipe some partition.
		SecureWipePartition(partition);
		}
		return true;
		}

recovery.cpp

+4 −165

Original line number	Diff line number	Diff line
		@@ -18,11 +18,9 @@

		#include <ctype.h>
		#include <errno.h>
		#include <fcntl.h>
		#include <getopt.h>
		#include <inttypes.h>
		#include <limits.h>
		#include <linux/fs.h>
		#include <linux/input.h>
		#include <stdio.h>
		#include <stdlib.h>
		@@ -30,8 +28,8 @@
		#include <sys/types.h>
		#include <unistd.h>

		#include <algorithm>
		#include <functional>
		#include <iterator>
		#include <memory>
		#include <string>
		#include <vector>
		@@ -42,12 +40,11 @@
		#include <android-base/properties.h>
		#include <android-base/stringprintf.h>
		#include <android-base/strings.h>
		#include <android-base/unique_fd.h>
		#include <bootloader_message/bootloader_message.h>
		#include <cutils/properties.h> /* for property_list */
		#include <healthhalutils/HealthHalUtils.h>
		#include <ziparchive/zip_archive.h>

		#include "bootloader_message/bootloader_message.h"
		#include "common.h"
		#include "fsck_unshare_blocks.h"
		#include "install/adb_install.h"
		@@ -55,6 +52,7 @@
		#include "install/install.h"
		#include "install/package.h"
		#include "install/wipe_data.h"
		#include "install/wipe_device.h"
		#include "otautil/error_code.h"
		#include "otautil/logging.h"
		#include "otautil/paths.h"
		@@ -221,165 +219,6 @@ static InstallResult prompt_and_wipe_data(Device* device) {
		}
		}

		// Secure-wipe a given partition. It uses BLKSECDISCARD, if supported. Otherwise, it goes with
		// BLKDISCARD (if device supports BLKDISCARDZEROES) or BLKZEROOUT.
		static bool secure_wipe_partition(const std::string& partition) {
		android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(partition.c_str(), O_WRONLY)));
		if (fd == -1) {
		PLOG(ERROR) << "Failed to open \"" << partition << "\"";
		return false;
		}

		uint64_t range[2] = { 0, 0 };
		if (ioctl(fd, BLKGETSIZE64, &range[1]) == -1 \|\| range[1] == 0) {
		PLOG(ERROR) << "Failed to get partition size";
		return false;
		}
		LOG(INFO) << "Secure-wiping \"" << partition << "\" from " << range[0] << " to " << range[1];

		LOG(INFO) << " Trying BLKSECDISCARD...";
		if (ioctl(fd, BLKSECDISCARD, &range) == -1) {
		PLOG(WARNING) << " Failed";

		// Use BLKDISCARD if it zeroes out blocks, otherwise use BLKZEROOUT.
		unsigned int zeroes;
		if (ioctl(fd, BLKDISCARDZEROES, &zeroes) == 0 && zeroes != 0) {
		LOG(INFO) << " Trying BLKDISCARD...";
		if (ioctl(fd, BLKDISCARD, &range) == -1) {
		PLOG(ERROR) << " Failed";
		return false;
		}
		} else {
		LOG(INFO) << " Trying BLKZEROOUT...";
		if (ioctl(fd, BLKZEROOUT, &range) == -1) {
		PLOG(ERROR) << " Failed";
		return false;
		}
		}
		}

		LOG(INFO) << " Done";
		return true;
		}

		static std::unique_ptr<Package> ReadWipePackage(size_t wipe_package_size) {
		if (wipe_package_size == 0) {
		LOG(ERROR) << "wipe_package_size is zero";
		return nullptr;
		}

		std::string wipe_package;
		std::string err_str;
		if (!read_wipe_package(&wipe_package, wipe_package_size, &err_str)) {
		PLOG(ERROR) << "Failed to read wipe package" << err_str;
		return nullptr;
		}

		return Package::CreateMemoryPackage(
		std::vector<uint8_t>(wipe_package.begin(), wipe_package.end()), nullptr);
		}

		// Checks if the wipe package matches expectation. If the check passes, reads the list of
		// partitions to wipe from the package. Checks include
		// 1. verify the package.
		// 2. check metadata (ota-type, pre-device and serial number if having one).
		static bool CheckWipePackage(Package* wipe_package) {
		if (!verify_package(wipe_package, ui)) {
		LOG(ERROR) << "Failed to verify package";
		return false;
		}

		ZipArchiveHandle zip = wipe_package->GetZipArchiveHandle();
		if (!zip) {
		LOG(ERROR) << "Failed to get ZipArchiveHandle";
		return false;
		}

		std::map<std::string, std::string> metadata;
		if (!ReadMetadataFromPackage(zip, &metadata)) {
		LOG(ERROR) << "Failed to parse metadata in the zip file";
		return false;
		}

		return CheckPackageMetadata(metadata, OtaType::BRICK) == 0;
		}

		std::vector<std::string> GetWipePartitionList(Package* wipe_package) {
		ZipArchiveHandle zip = wipe_package->GetZipArchiveHandle();
		if (!zip) {
		LOG(ERROR) << "Failed to get ZipArchiveHandle";
		return {};
		}

		static constexpr const char* RECOVERY_WIPE_ENTRY_NAME = "recovery.wipe";

		std::string partition_list_content;
		ZipString path(RECOVERY_WIPE_ENTRY_NAME);
		ZipEntry entry;
		if (FindEntry(zip, path, &entry) == 0) {
		uint32_t length = entry.uncompressed_length;
		partition_list_content = std::string(length, '\0');
		if (auto err = ExtractToMemory(
		zip, &entry, reinterpret_cast<uint8_t*>(partition_list_content.data()), length);
		err != 0) {
		LOG(ERROR) << "Failed to extract " << RECOVERY_WIPE_ENTRY_NAME << ": "
		<< ErrorCodeString(err);
		return {};
		}
		} else {
		LOG(INFO) << "Failed to find " << RECOVERY_WIPE_ENTRY_NAME
		<< ", falling back to use the partition list on device.";

		static constexpr const char* RECOVERY_WIPE_ON_DEVICE = "/etc/recovery.wipe";
		if (!android::base::ReadFileToString(RECOVERY_WIPE_ON_DEVICE, &partition_list_content)) {
		PLOG(ERROR) << "failed to read \"" << RECOVERY_WIPE_ON_DEVICE << "\"";
		return {};
		}
		}

		std::vector<std::string> result;
		std::vector<std::string> lines = android::base::Split(partition_list_content, "\n");
		for (const std::string& line : lines) {
		std::string partition = android::base::Trim(line);
		// Ignore '#' comment or empty lines.
		if (android::base::StartsWith(partition, "#") \|\| partition.empty()) {
		continue;
		}
		result.push_back(line);
		}

		return result;
		}

		// Wipes the current A/B device, with a secure wipe of all the partitions in RECOVERY_WIPE.
		static bool wipe_ab_device(size_t wipe_package_size) {
		ui->SetBackground(RecoveryUI::ERASING);
		ui->SetProgressType(RecoveryUI::INDETERMINATE);

		auto wipe_package = ReadWipePackage(wipe_package_size);
		if (!wipe_package) {
		LOG(ERROR) << "Failed to open wipe package";
		return false;
		}

		if (!CheckWipePackage(wipe_package.get())) {
		LOG(ERROR) << "Failed to verify wipe package";
		return false;
		}

		auto partition_list = GetWipePartitionList(wipe_package.get());
		if (partition_list.empty()) {
		LOG(ERROR) << "Empty wipe ab partition list";
		return false;
		}

		for (const auto& partition : partition_list) {
		// Proceed anyway even if it fails to wipe some partition.
		secure_wipe_partition(partition);
		}
		return true;
		}

		static void choose_recovery_file(Device* device) {
		std::vector<std::string> entries;
		if (has_cache) {
		@@ -934,7 +773,7 @@ Device::BuiltinAction start_recovery(Device* device, const std::vector<std::stri
		status = INSTALL_ERROR;
		}
		} else if (should_wipe_ab) {
		if (!wipe_ab_device(wipe_package_size)) {
		if (!WipeAbDevice(device, wipe_package_size)) {
		status = INSTALL_ERROR;
		}
		} else if (sideload) {