rm -rf non-AB code (c7ebad5f) · Commits · e / os / android_bootable_recovery

Android.bp

+4 −1

Original line number	Diff line number	Diff line
		@@ -35,7 +35,10 @@ package {
		// See: http://go/android-license-faq
		license {
		name: "bootable_recovery_license",
		visibility: [":__subpackages__"],
		visibility: [
		":__subpackages__",
		"//bootable/deprecated-ota:__subpackages__",
		],
		license_kinds: [
		"SPDX-license-identifier-Apache-2.0",
		"SPDX-license-identifier-MIT",

Android.mk

+0 −2

Original line number	Diff line number	Diff line
		@@ -84,5 +84,3 @@ endif

		include $(BUILD_PHONY_PACKAGE)

		include \
		$(LOCAL_PATH)/updater/Android.mk \

applypatch/Android.bp

deleted100644 → 0

+0 −201

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

		package {
		default_applicable_licenses: ["bootable_recovery_applypatch_license"],
		}

		// Added automatically by a large-scale-change
		// See: http://go/android-license-faq
		license {
		name: "bootable_recovery_applypatch_license",
		visibility: [":__subpackages__"],
		license_kinds: [
		"SPDX-license-identifier-Apache-2.0",
		],
		license_text: [
		"NOTICE",
		],
		}

		cc_defaults {
		name: "applypatch_defaults",

		cflags: [
		"-D_FILE_OFFSET_BITS=64",
		"-DZLIB_CONST",
		"-Wall",
		"-Werror",
		],

		local_include_dirs: [
		"include",
		],
		}

		cc_library_static {
		name: "libapplypatch",

		host_supported: true,
		vendor_available: true,

		defaults: [
		"applypatch_defaults",
		],

		srcs: [
		"applypatch.cpp",
		"bspatch.cpp",
		"freecache.cpp",
		"imgpatch.cpp",
		],

		export_include_dirs: [
		"include",
		],

		static_libs: [
		"libbase",
		"libbspatch",
		"libbz",
		"libedify",
		"libotautil",
		"libz_stable",
		],

		shared_libs: [
		"libcrypto",
		],

		target: {
		darwin: {
		enabled: false,
		},
		},
		}

		cc_library_static {
		name: "libapplypatch_modes",
		vendor_available: true,

		defaults: [
		"applypatch_defaults",
		],

		srcs: [
		"applypatch_modes.cpp",
		],

		static_libs: [
		"libapplypatch",
		"libbase",
		"libedify",
		"libotautil",
		],

		shared_libs: [
		"libcrypto",
		],
		}

		cc_binary {
		name: "applypatch",
		vendor: true,

		defaults: [
		"applypatch_defaults",
		],

		srcs: [
		"applypatch_main.cpp",
		],

		static_libs: [
		"libapplypatch_modes",
		"libapplypatch",
		"libedify",
		"libotautil",

		// External dependencies.
		"libbspatch",
		"libbrotli",
		"libbz",
		],

		shared_libs: [
		"libbase",
		"libcrypto",
		"liblog",
		"libz_stable",
		"libziparchive",
		],

		init_rc: [
		"vendor_flash_recovery.rc",
		],
		}

		cc_library_static {
		name: "libimgdiff",
		host_supported: true,
		defaults: [
		"applypatch_defaults",
		],

		srcs: [
		"imgdiff.cpp",
		],

		export_include_dirs: [
		"include",
		],

		static_libs: [
		"libbase",
		"libbsdiff",
		"libdivsufsort",
		"libdivsufsort64",
		"liblog",
		"libotautil",
		"libutils",
		"libz_stable",
		"libziparchive",
		],
		}

		cc_binary_host {
		name: "imgdiff",
		srcs: [
		"imgdiff_main.cpp",
		],

		defaults: [
		"applypatch_defaults",
		],

		static_libs: [
		"libimgdiff",
		"libotautil",
		"libbsdiff",
		"libdivsufsort",
		"libdivsufsort64",
		"libziparchive",
		"libbase",
		"libutils",
		"liblog",
		"libbrotli",
		"libbz",
		"libz_stable",
		],
		}

applypatch/NOTICE

deleted100644 → 0

+0 −41

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


		bsdiff.c
		bspatch.c

		Copyright 2003-2005 Colin Percival
		All rights reserved

		Redistribution and use in source and binary forms, with or without
		modification, are permitted providing that the following conditions
		are met:
		1. Redistributions of source code must retain the above copyright
		notice, this list of conditions and the following disclaimer.
		2. Redistributions in binary form must reproduce the above copyright
		notice, this list of conditions and the following disclaimer in the
		documentation and/or other materials provided with the distribution.

		THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
		IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
		WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
		DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
		OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
		STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
		IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
		POSSIBILITY OF SUCH DAMAGE.

applypatch/applypatch.cpp

deleted100644 → 0

+0 −457

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

		#include <errno.h>
		#include <fcntl.h>
		#include <libgen.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <sys/stat.h>
		#include <sys/types.h>
		#include <unistd.h>

		#include <algorithm>
		#include <functional>
		#include <memory>
		#include <string>
		#include <utility>
		#include <vector>

		#include <android-base/file.h>
		#include <android-base/logging.h>
		#include <android-base/parseint.h>
		#include <android-base/strings.h>
		#include <android-base/unique_fd.h>
		#include <openssl/sha.h>

		#include "edify/expr.h"
		#include "otautil/paths.h"
		#include "otautil/print_sha1.h"

		using namespace std::string_literals;

		static bool GenerateTarget(const Partition& target, const FileContents& source_file,
		const Value& patch, const Value* bonus_data, bool backup_source);

		bool LoadFileContents(const std::string& filename, FileContents* file) {
		// No longer allow loading contents from eMMC partitions.
		if (android::base::StartsWith(filename, "EMMC:")) {
		return false;
		}

		std::string data;
		if (!android::base::ReadFileToString(filename, &data)) {
		PLOG(ERROR) << "Failed to read \"" << filename << "\"";
		return false;
		}

		file->data = std::vector<unsigned char>(data.begin(), data.end());
		SHA1(file->data.data(), file->data.size(), file->sha1);
		return true;
		}

		// Reads the contents of a Partition to the given FileContents buffer.
		static bool ReadPartitionToBuffer(const Partition& partition, FileContents* out,
		bool check_backup) {
		uint8_t expected_sha1[SHA_DIGEST_LENGTH];
		if (ParseSha1(partition.hash, expected_sha1) != 0) {
		LOG(ERROR) << "Failed to parse target hash \"" << partition.hash << "\"";
		return false;
		}

		android::base::unique_fd dev(open(partition.name.c_str(), O_RDONLY));
		if (dev == -1) {
		PLOG(ERROR) << "Failed to open eMMC partition \"" << partition << "\"";
		} else {
		std::vector<unsigned char> buffer(partition.size);
		if (!android::base::ReadFully(dev, buffer.data(), buffer.size())) {
		PLOG(ERROR) << "Failed to read " << buffer.size() << " bytes of data for partition "
		<< partition;
		} else {
		SHA1(buffer.data(), buffer.size(), out->sha1);
		if (memcmp(out->sha1, expected_sha1, SHA_DIGEST_LENGTH) == 0) {
		out->data = std::move(buffer);
		return true;
		}
		}
		}

		if (!check_backup) {
		LOG(ERROR) << "Partition contents don't have the expected checksum";
		return false;
		}

		if (LoadFileContents(Paths::Get().cache_temp_source(), out) &&
		memcmp(out->sha1, expected_sha1, SHA_DIGEST_LENGTH) == 0) {
		return true;
		}

		LOG(ERROR) << "Both of partition contents and backup don't have the expected checksum";
		return false;
		}

		bool SaveFileContents(const std::string& filename, const FileContents* file) {
		android::base::unique_fd fd(
		open(filename.c_str(), O_WRONLY \| O_CREAT \| O_TRUNC \| O_SYNC, S_IRUSR \| S_IWUSR));
		if (fd == -1) {
		PLOG(ERROR) << "Failed to open \"" << filename << "\" for write";
		return false;
		}

		if (!android::base::WriteFully(fd, file->data.data(), file->data.size())) {
		PLOG(ERROR) << "Failed to write " << file->data.size() << " bytes of data to " << filename;
		return false;
		}

		if (fsync(fd) != 0) {
		PLOG(ERROR) << "Failed to fsync \"" << filename << "\"";
		return false;
		}

		if (close(fd.release()) != 0) {
		PLOG(ERROR) << "Failed to close \"" << filename << "\"";
		return false;
		}

		return true;
		}

		// Writes a memory buffer to 'target' Partition.
		static bool WriteBufferToPartition(const FileContents& file_contents, const Partition& partition) {
		const unsigned char* data = file_contents.data.data();
		size_t len = file_contents.data.size();
		size_t start = 0;
		bool success = false;
		for (size_t attempt = 0; attempt < 2; ++attempt) {
		android::base::unique_fd fd(open(partition.name.c_str(), O_RDWR));
		if (fd == -1) {
		PLOG(ERROR) << "Failed to open \"" << partition << "\"";
		return false;
		}

		if (TEMP_FAILURE_RETRY(lseek(fd, start, SEEK_SET)) == -1) {
		PLOG(ERROR) << "Failed to seek to " << start << " on \"" << partition << "\"";
		return false;
		}

		if (!android::base::WriteFully(fd, data + start, len - start)) {
		PLOG(ERROR) << "Failed to write " << len - start << " bytes to \"" << partition << "\"";
		return false;
		}

		if (fsync(fd) != 0) {
		PLOG(ERROR) << "Failed to sync \"" << partition << "\"";
		return false;
		}
		if (close(fd.release()) != 0) {
		PLOG(ERROR) << "Failed to close \"" << partition << "\"";
		return false;
		}

		fd.reset(open(partition.name.c_str(), O_RDONLY));
		if (fd == -1) {
		PLOG(ERROR) << "Failed to reopen \"" << partition << "\" for verification";
		return false;
		}

		// Drop caches so our subsequent verification read won't just be reading the cache.
		sync();
		std::string drop_cache = "/proc/sys/vm/drop_caches";
		if (!android::base::WriteStringToFile("3\n", drop_cache)) {
		PLOG(ERROR) << "Failed to write to " << drop_cache;
		} else {
		LOG(INFO) << " caches dropped";
		}
		sleep(1);

		// Verify.
		if (TEMP_FAILURE_RETRY(lseek(fd, 0, SEEK_SET)) == -1) {
		PLOG(ERROR) << "Failed to seek to 0 on " << partition;
		return false;
		}

		unsigned char buffer[4096];
		start = len;
		for (size_t p = 0; p < len; p += sizeof(buffer)) {
		size_t to_read = len - p;
		if (to_read > sizeof(buffer)) {
		to_read = sizeof(buffer);
		}

		if (!android::base::ReadFully(fd, buffer, to_read)) {
		PLOG(ERROR) << "Failed to verify-read " << partition << " at " << p;
		return false;
		}

		if (memcmp(buffer, data + p, to_read) != 0) {
		LOG(ERROR) << "Verification failed starting at " << p;
		start = p;
		break;
		}
		}

		if (start == len) {
		LOG(INFO) << "Verification read succeeded (attempt " << attempt + 1 << ")";
		success = true;
		break;
		}

		if (close(fd.release()) != 0) {
		PLOG(ERROR) << "Failed to close " << partition;
		return false;
		}
		}

		if (!success) {
		LOG(ERROR) << "Failed to verify after all attempts";
		return false;
		}

		sync();

		return true;
		}

		int ParseSha1(const std::string& str, uint8_t* digest) {
		const char* ps = str.c_str();
		uint8_t* pd = digest;
		for (int i = 0; i < SHA_DIGEST_LENGTH * 2; ++i, ++ps) {
		int digit;
		if (ps >= '0' && ps <= '9') {
		digit = *ps - '0';
		} else if (ps >= 'a' && ps <= 'f') {
		digit = *ps - 'a' + 10;
		} else if (ps >= 'A' && ps <= 'F') {
		digit = *ps - 'A' + 10;
		} else {
		return -1;
		}
		if (i % 2 == 0) {
		*pd = digit << 4;
		} else {
		*pd \|= digit;
		++pd;
		}
		}
		if (*ps != '\0') return -1;
		return 0;
		}

		bool PatchPartitionCheck(const Partition& target, const Partition& source) {
		FileContents target_file;
		FileContents source_file;
		return (ReadPartitionToBuffer(target, &target_file, false) \|\|
		ReadPartitionToBuffer(source, &source_file, true));
		}

		int ShowLicenses() {
		ShowBSDiffLicense();
		return 0;
		}

		bool PatchPartition(const Partition& target, const Partition& source, const Value& patch,
		const Value* bonus, bool backup_source) {
		LOG(INFO) << "Patching " << target.name;

		// We try to load and check against the target hash first.
		FileContents target_file;
		if (ReadPartitionToBuffer(target, &target_file, false)) {
		// The early-exit case: the patch was already applied, this file has the desired hash, nothing
		// for us to do.
		LOG(INFO) << " already " << target.hash.substr(0, 8);
		return true;
		}

		FileContents source_file;
		if (ReadPartitionToBuffer(source, &source_file, backup_source)) {
		return GenerateTarget(target, source_file, patch, bonus, backup_source);
		}

		LOG(ERROR) << "Failed to find any match";
		return false;
		}

		bool FlashPartition(const Partition& partition, const std::string& source_filename) {
		LOG(INFO) << "Flashing " << partition;

		// We try to load and check against the target hash first.
		FileContents target_file;
		if (ReadPartitionToBuffer(partition, &target_file, false)) {
		// The early-exit case: the patch was already applied, this file has the desired hash, nothing
		// for us to do.
		LOG(INFO) << " already " << partition.hash.substr(0, 8);
		return true;
		}

		FileContents source_file;
		if (!LoadFileContents(source_filename, &source_file)) {
		LOG(ERROR) << "Failed to load source file";
		return false;
		}

		uint8_t expected_sha1[SHA_DIGEST_LENGTH];
		if (ParseSha1(partition.hash, expected_sha1) != 0) {
		LOG(ERROR) << "Failed to parse source hash \"" << partition.hash << "\"";
		return false;
		}

		if (memcmp(source_file.sha1, expected_sha1, SHA_DIGEST_LENGTH) != 0) {
		// The source doesn't have desired checksum.
		LOG(ERROR) << "source \"" << source_filename << "\" doesn't have expected SHA-1 sum";
		LOG(ERROR) << "expected: " << partition.hash.substr(0, 8)
		<< ", found: " << short_sha1(source_file.sha1);
		return false;
		}
		if (!WriteBufferToPartition(source_file, partition)) {
		LOG(ERROR) << "Failed to write to " << partition;
		return false;
		}
		return true;
		}

		static bool GenerateTarget(const Partition& target, const FileContents& source_file,
		const Value& patch, const Value* bonus_data, bool backup_source) {
		uint8_t expected_sha1[SHA_DIGEST_LENGTH];
		if (ParseSha1(target.hash, expected_sha1) != 0) {
		LOG(ERROR) << "Failed to parse target hash \"" << target.hash << "\"";
		return false;
		}

		if (patch.type != Value::Type::BLOB) {
		LOG(ERROR) << "patch is not a blob";
		return false;
		}

		const char* header = patch.data.data();
		size_t header_bytes_read = patch.data.size();
		bool use_bsdiff = false;
		if (header_bytes_read >= 8 && memcmp(header, "BSDIFF40", 8) == 0) {
		use_bsdiff = true;
		} else if (header_bytes_read >= 8 && memcmp(header, "IMGDIFF2", 8) == 0) {
		use_bsdiff = false;
		} else {
		LOG(ERROR) << "Unknown patch file format";
		return false;
		}

		// We write the original source to cache, in case the partition write is interrupted.
		if (backup_source && !CheckAndFreeSpaceOnCache(source_file.data.size())) {
		LOG(ERROR) << "Not enough free space on /cache";
		return false;
		}
		if (backup_source && !SaveFileContents(Paths::Get().cache_temp_source(), &source_file)) {
		LOG(ERROR) << "Failed to back up source file";
		return false;
		}

		// We store the decoded output in memory.
		FileContents patched;
		SHA_CTX ctx;
		SHA1_Init(&ctx);
		SinkFn sink = [&patched, &ctx](const unsigned char* data, size_t len) {
		SHA1_Update(&ctx, data, len);
		patched.data.insert(patched.data.end(), data, data + len);
		return len;
		};

		int result;
		if (use_bsdiff) {
		result = ApplyBSDiffPatch(source_file.data.data(), source_file.data.size(), patch, 0, sink);
		} else {
		result =
		ApplyImagePatch(source_file.data.data(), source_file.data.size(), patch, sink, bonus_data);
		}

		if (result != 0) {
		LOG(ERROR) << "Failed to apply the patch: " << result;
		return false;
		}

		SHA1_Final(patched.sha1, &ctx);
		if (memcmp(patched.sha1, expected_sha1, SHA_DIGEST_LENGTH) != 0) {
		LOG(ERROR) << "Patching did not produce the expected SHA-1 of " << short_sha1(expected_sha1);

		LOG(ERROR) << "target size " << patched.data.size() << " SHA-1 " << short_sha1(patched.sha1);
		LOG(ERROR) << "source size " << source_file.data.size() << " SHA-1 "
		<< short_sha1(source_file.sha1);

		uint8_t patch_digest[SHA_DIGEST_LENGTH];
		SHA1(reinterpret_cast<const uint8_t*>(patch.data.data()), patch.data.size(), patch_digest);
		LOG(ERROR) << "patch size " << patch.data.size() << " SHA-1 " << short_sha1(patch_digest);

		if (bonus_data != nullptr) {
		uint8_t bonus_digest[SHA_DIGEST_LENGTH];
		SHA1(reinterpret_cast<const uint8_t*>(bonus_data->data.data()), bonus_data->data.size(),
		bonus_digest);
		LOG(ERROR) << "bonus size " << bonus_data->data.size() << " SHA-1 "
		<< short_sha1(bonus_digest);
		}

		return false;
		}

		LOG(INFO) << " now " << short_sha1(expected_sha1);

		// Write back the temp file to the partition.
		if (!WriteBufferToPartition(patched, target)) {
		LOG(ERROR) << "Failed to write patched data to " << target.name;
		return false;
		}

		// Delete the backup copy of the source.
		if (backup_source) {
		unlink(Paths::Get().cache_temp_source().c_str());
		}

		// Success!
		return true;
		}

		bool CheckPartition(const Partition& partition) {
		FileContents target_file;
		return ReadPartitionToBuffer(partition, &target_file, false);
		}

		Partition Partition::Parse(const std::string& input_str, std::string* err) {
		std::vector<std::string> pieces = android::base::Split(input_str, ":");
		if (pieces.size() != 4 \|\| pieces[0] != "EMMC") {
		*err = "Invalid number of tokens or non-eMMC target";
		return {};
		}

		size_t size;
		if (!android::base::ParseUint(pieces[2], &size) \|\| size == 0) {
		*err = "Failed to parse \"" + pieces[2] + "\" as byte count";
		return {};
		}

		return Partition(pieces[1], size, pieces[3]);
		}

		std::string Partition::ToString() const {
		if (*this) {
		return "EMMC:"s + name + ":" + std::to_string(size) + ":" + hash;
		}
		return "<invalid-partition>";
		}

		std::ostream& operator<<(std::ostream& os, const Partition& partition) {
		os << partition.ToString();
		return os;
		}