diff --git a/Android.mk b/Android.mk index 55377755..94b2cd66 100644 --- a/Android.mk +++ b/Android.mk @@ -571,23 +571,27 @@ include $(CLEAR_VARS) LOCAL_MODULE := libaosprecovery LOCAL_MODULE_TAGS := eng optional LOCAL_CFLAGS := -std=gnu++0x -LOCAL_SRC_FILES := adb_install.cpp asn1_decoder.cpp legacy_property_service.cpp set_metadata.cpp tw_atomic.cpp -LOCAL_SHARED_LIBRARIES += libc liblog libcutils libmtdutils libfusesideload libselinux +LOCAL_SRC_FILES := adb_install.cpp asn1_decoder.cpp legacy_property_service.cpp set_metadata.cpp tw_atomic.cpp installcommand.cpp +LOCAL_SHARED_LIBRARIES += libc liblog libcutils libmtdutils libfusesideload libselinux libminzip +LOCAL_CFLAGS += -DRECOVERY_API_VERSION=$(RECOVERY_API_VERSION) ifeq ($(shell test $(PLATFORM_SDK_VERSION) -lt 23; echo $$?),0) LOCAL_SHARED_LIBRARIES += libstdc++ libstlport - LOCAL_C_INCLUDES := bionic external/stlport/stlport + LOCAL_C_INCLUDES += bionic external/stlport/stlport else LOCAL_SHARED_LIBRARIES += libc++ endif ifeq ($(shell test $(PLATFORM_SDK_VERSION) -lt 24; echo $$?),0) LOCAL_SHARED_LIBRARIES += libmincrypttwrp - LOCAL_C_INCLUDES := $(LOCAL_PATH)/libmincrypt/includes + LOCAL_C_INCLUDES += $(LOCAL_PATH)/libmincrypt/includes LOCAL_SRC_FILES += verifier24/verifier.cpp LOCAL_CFLAGS += -DUSE_OLD_VERIFIER else - LOCAL_SHARED_LIBRARIES += libcrypto + LOCAL_SHARED_LIBRARIES += libcrypto libbase LOCAL_SRC_FILES += verifier.cpp endif +ifeq ($(AB_OTA_UPDATER),true) + LOCAL_CFLAGS += -DAB_OTA_UPDATER=1 +endif ifneq ($(BOARD_RECOVERY_BLDRMSG_OFFSET),) LOCAL_CFLAGS += -DBOARD_RECOVERY_BLDRMSG_OFFSET=$(BOARD_RECOVERY_BLDRMSG_OFFSET) diff --git a/gui/theme/common/languages/en.xml b/gui/theme/common/languages/en.xml index f4344a05..b82aecff 100644 --- a/gui/theme/common/languages/en.xml +++ b/gui/theme/common/languages/en.xml @@ -621,7 +621,7 @@ Recovery Commands Complete Running OpenRecoveryScript OpenRecoveryScript Complete - Could not find '{1}' in the zip file. + Invalid zip file format! Checking for MD5 file... Failed to map file '{1}' Verifying zip signature... diff --git a/installcommand.cpp b/installcommand.cpp new file mode 100644 index 00000000..ba641436 --- /dev/null +++ b/installcommand.cpp @@ -0,0 +1,260 @@ +/* + * Copyright (C) 2007 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 +#include +#include + +#ifdef AB_OTA_UPDATER +#include +#include +#include +#include +#endif +#include + +#include "common.h" +#include "installcommand.h" +#include "minzip/SysUtil.h" +#include "minzip/Zip.h" +#ifdef USE_OLD_VERIFIER +#include "verifier24/verifier.h" +#else +#include "verifier.h" +#endif + +#ifdef AB_OTA_UPDATER + +static constexpr const char* AB_OTA_PAYLOAD_PROPERTIES = "payload_properties.txt"; +static constexpr const char* AB_OTA_PAYLOAD = "payload.bin"; +static constexpr const char* METADATA_PATH = "META-INF/com/android/metadata"; + +// This function parses and returns the build.version.incremental +static int parse_build_number(std::string str) { + size_t pos = str.find("="); + if (pos != std::string::npos) { + std::string num_string = android::base::Trim(str.substr(pos+1)); + int build_number; + if (android::base::ParseInt(num_string.c_str(), &build_number, 0)) { + return build_number; + } + } + + printf("Failed to parse build number in %s.\n", str.c_str()); + return -1; +} + +bool read_metadata_from_package(ZipArchive* zip, std::string* meta_data) { + const ZipEntry* meta_entry = mzFindZipEntry(zip, METADATA_PATH); + if (meta_entry == nullptr) { + printf("Failed to find %s in update package.\n", METADATA_PATH); + return false; + } + + meta_data->resize(meta_entry->uncompLen, '\0'); + if (!mzReadZipEntry(zip, meta_entry, &(*meta_data)[0], meta_entry->uncompLen)) { + printf("Failed to read metadata in update package.\n"); + return false; + } + return true; +} + +// Read the build.version.incremental of src/tgt from the metadata and log it to last_install. +static void read_source_target_build(ZipArchive* zip, std::vector& log_buffer) { + std::string meta_data; + if (!read_metadata_from_package(zip, &meta_data)) { + return; + } + // Examples of the pre-build and post-build strings in metadata: + // pre-build-incremental=2943039 + // post-build-incremental=2951741 + std::vector lines = android::base::Split(meta_data, "\n"); + for (const std::string& line : lines) { + std::string str = android::base::Trim(line); + if (android::base::StartsWith(str, "pre-build-incremental")){ + int source_build = parse_build_number(str); + if (source_build != -1) { + log_buffer.push_back(android::base::StringPrintf("source_build: %d", + source_build)); + } + } else if (android::base::StartsWith(str, "post-build-incremental")) { + int target_build = parse_build_number(str); + if (target_build != -1) { + log_buffer.push_back(android::base::StringPrintf("target_build: %d", + target_build)); + } + } + } +} + +// Parses the metadata of the OTA package in |zip| and checks whether we are +// allowed to accept this A/B package. Downgrading is not allowed unless +// explicitly enabled in the package and only for incremental packages. +static int check_newer_ab_build(ZipArchive* zip) +{ + std::string metadata_str; + if (!read_metadata_from_package(zip, &metadata_str)) { + return INSTALL_CORRUPT; + } + std::map metadata; + for (const std::string& line : android::base::Split(metadata_str, "\n")) { + size_t eq = line.find('='); + if (eq != std::string::npos) { + metadata[line.substr(0, eq)] = line.substr(eq + 1); + } + } + char value[PROPERTY_VALUE_MAX]; + + property_get("ro.product.device", value, ""); + const std::string& pkg_device = metadata["pre-device"]; + if (pkg_device != value || pkg_device.empty()) { + printf("Package is for product %s but expected %s\n", + pkg_device.c_str(), value); + return INSTALL_ERROR; + } + + // We allow the package to not have any serialno, but if it has a non-empty + // value it should match. + property_get("ro.serialno", value, ""); + const std::string& pkg_serial_no = metadata["serialno"]; + if (!pkg_serial_no.empty() && pkg_serial_no != value) { + printf("Package is for serial %s\n", pkg_serial_no.c_str()); + return INSTALL_ERROR; + } + + if (metadata["ota-type"] != "AB") { + printf("Package is not A/B\n"); + return INSTALL_ERROR; + } + + // Incremental updates should match the current build. + property_get("ro.build.version.incremental", value, ""); + const std::string& pkg_pre_build = metadata["pre-build-incremental"]; + if (!pkg_pre_build.empty() && pkg_pre_build != value) { + printf("Package is for source build %s but expected %s\n", + pkg_pre_build.c_str(), value); + return INSTALL_ERROR; + } + property_get("ro.build.fingerprint", value, ""); + const std::string& pkg_pre_build_fingerprint = metadata["pre-build"]; + if (!pkg_pre_build_fingerprint.empty() && + pkg_pre_build_fingerprint != value) { + printf("Package is for source build %s but expected %s\n", + pkg_pre_build_fingerprint.c_str(), value); + return INSTALL_ERROR; + } + + // Check for downgrade version. + int64_t build_timestampt = property_get_int64( + "ro.build.date.utc", std::numeric_limits::max()); + int64_t pkg_post_timespampt = 0; + // We allow to full update to the same version we are running, in case there + // is a problem with the current copy of that version. + if (metadata["post-timestamp"].empty() || + !android::base::ParseInt(metadata["post-timestamp"].c_str(), + &pkg_post_timespampt) || + pkg_post_timespampt < build_timestampt) { + if (metadata["ota-downgrade"] != "yes") { + printf("Update package is older than the current build, expected a " + "build newer than timestamp %" PRIu64 " but package has " + "timestamp %" PRIu64 " and downgrade not allowed.\n", + build_timestampt, pkg_post_timespampt); + return INSTALL_ERROR; + } + if (pkg_pre_build_fingerprint.empty()) { + printf("Downgrade package must have a pre-build version set, not " + "allowed.\n"); + return INSTALL_ERROR; + } + } + + return 0; +} + +int +abupdate_binary_command(const char* path, ZipArchive* zip, int retry_count, + int status_fd, std::vector* cmd) +{ + int ret = check_newer_ab_build(zip); + if (ret) { + return ret; + } + + // For A/B updates we extract the payload properties to a buffer and obtain + // the RAW payload offset in the zip file. + const ZipEntry* properties_entry = + mzFindZipEntry(zip, AB_OTA_PAYLOAD_PROPERTIES); + if (!properties_entry) { + printf("Can't find %s\n", AB_OTA_PAYLOAD_PROPERTIES); + return INSTALL_CORRUPT; + } + std::vector payload_properties( + mzGetZipEntryUncompLen(properties_entry)); + if (!mzExtractZipEntryToBuffer(zip, properties_entry, + payload_properties.data())) { + printf("Can't extract %s\n", AB_OTA_PAYLOAD_PROPERTIES); + return INSTALL_CORRUPT; + } + + const ZipEntry* payload_entry = mzFindZipEntry(zip, AB_OTA_PAYLOAD); + if (!payload_entry) { + printf("Can't find %s\n", AB_OTA_PAYLOAD); + return INSTALL_CORRUPT; + } + long payload_offset = mzGetZipEntryOffset(payload_entry); + *cmd = { + "/sbin/update_engine_sideload", + android::base::StringPrintf("--payload=file://%s", path), + android::base::StringPrintf("--offset=%ld", payload_offset), + "--headers=" + std::string(payload_properties.begin(), + payload_properties.end()), + android::base::StringPrintf("--status_fd=%d", status_fd), + }; + return INSTALL_SUCCESS; +} + +#else + +int +abupdate_binary_command(const char* path, ZipArchive* zip, int retry_count, + int status_fd, std::vector* cmd) +{ + printf("No support for AB OTA zips included\n"); + return INSTALL_CORRUPT; +} + +#endif + +int +update_binary_command(const char* path, ZipArchive* zip, int retry_count, + int status_fd, std::vector* cmd) +{ + char charfd[16]; + sprintf(charfd, "%i", status_fd); + cmd->push_back(TMP_UPDATER_BINARY_PATH); + cmd->push_back(EXPAND(RECOVERY_API_VERSION)); + cmd->push_back(charfd); + cmd->push_back(path); + /**cmd = { + TMP_UPDATER_BINARY_PATH, + EXPAND(RECOVERY_API_VERSION), // defined in Android.mk + charfd, + path, + };*/ + if (retry_count > 0) + cmd->push_back("retry"); + return 0; +} diff --git a/installcommand.h b/installcommand.h new file mode 100644 index 00000000..505640e0 --- /dev/null +++ b/installcommand.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2007 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. + */ + +#ifndef RECOVERY_INSTALL_COMMAND_H_ +#define RECOVERY_INSTALL_COMMAND_H_ + +#define TMP_UPDATER_BINARY_PATH "/tmp/updater" + +#include + +#include "minzip/Zip.h" + +bool read_metadata_from_package(ZipArchive* zip, std::string* meta_data); + +int +abupdate_binary_command(const char* path, ZipArchive* zip, int retry_count, + int status_fd, std::vector* cmd); +int +update_binary_command(const char* path, ZipArchive* zip, int retry_count, + int status_fd, std::vector* cmd); + +#endif // RECOVERY_INSTALL_COMMAND_H_ diff --git a/twinstall.cpp b/twinstall.cpp index 50d286c4..75d9a489 100644 --- a/twinstall.cpp +++ b/twinstall.cpp @@ -45,15 +45,26 @@ #include "gui/gui.hpp" #include "gui/pages.hpp" #include "legacy_property_service.h" +#include "twinstall.h" +#include "installcommand.h" extern "C" { #include "gui/gui.h" } +#define AB_OTA "payload_properties.txt" + static const char* properties_path = "/dev/__properties__"; static const char* properties_path_renamed = "/dev/__properties_kk__"; static bool legacy_props_env_initd = false; static bool legacy_props_path_modified = false; +enum zip_type { + UNKNOWN_ZIP_TYPE = 0, + UPDATE_BINARY_ZIP_TYPE, + AB_OTA_ZIP_TYPE, + TWRP_THEME_ZIP_TYPE +}; + // to support pre-KitKat update-binaries that expect properties in the legacy format static int switch_to_legacy_properties() { @@ -126,26 +137,22 @@ static int Install_Theme(const char* path, ZipArchive *Zip) { #endif } -static int Run_Update_Binary(const char *path, ZipArchive *Zip, int* wipe_cache) { +static int Prepare_Update_Binary(const char *path, ZipArchive *Zip, int* wipe_cache) { const ZipEntry* binary_location = mzFindZipEntry(Zip, ASSUMED_UPDATE_BINARY_NAME); - string Temp_Binary = "/tmp/updater"; // Note: AOSP names it /tmp/update_binary (yes, with "_") - int binary_fd, ret_val, pipe_fd[2], status, zip_verify; - char buffer[1024]; - const char** args = (const char**)malloc(sizeof(char*) * 5); - FILE* child_data; + int binary_fd, ret_val; if (binary_location == NULL) { return INSTALL_CORRUPT; } // Delete any existing updater - if (TWFunc::Path_Exists(Temp_Binary) && unlink(Temp_Binary.c_str()) != 0) { - LOGINFO("Unable to unlink '%s': %s\n", Temp_Binary.c_str(), strerror(errno)); + if (TWFunc::Path_Exists(TMP_UPDATER_BINARY_PATH) && unlink(TMP_UPDATER_BINARY_PATH) != 0) { + LOGINFO("Unable to unlink '%s': %s\n", TMP_UPDATER_BINARY_PATH, strerror(errno)); } - binary_fd = creat(Temp_Binary.c_str(), 0755); + binary_fd = creat(TMP_UPDATER_BINARY_PATH, 0755); if (binary_fd < 0) { - LOGERR("Could not create file for updater extract in '%s': %s\n", Temp_Binary.c_str(), strerror(errno)); + LOGERR("Could not create file for updater extract in '%s': %s\n", TMP_UPDATER_BINARY_PATH, strerror(errno)); mzCloseZipArchive(Zip); return INSTALL_ERROR; } @@ -189,6 +196,13 @@ static int Run_Update_Binary(const char *path, ZipArchive *Zip, int* wipe_cache) } } mzCloseZipArchive(Zip); + return INSTALL_SUCCESS; +} + +static int Run_Update_Binary(const char *path, ZipArchive *Zip, int* wipe_cache, zip_type ztype) { + int ret_val, pipe_fd[2], status, zip_verify; + char buffer[1024]; + FILE* child_data; #ifndef TW_NO_LEGACY_PROPS /* Set legacy properties */ @@ -201,25 +215,35 @@ static int Run_Update_Binary(const char *path, ZipArchive *Zip, int* wipe_cache) pipe(pipe_fd); - args[0] = Temp_Binary.c_str(); - args[1] = EXPAND(RECOVERY_API_VERSION); - char* temp = (char*)malloc(10); - sprintf(temp, "%d", pipe_fd[1]); - args[2] = temp; - args[3] = (char*)path; - args[4] = NULL; + std::vector args; + if (ztype == UPDATE_BINARY_ZIP_TYPE) { + ret_val = update_binary_command(path, Zip, 0, pipe_fd[1], &args); + } else if (ztype == AB_OTA_ZIP_TYPE) { + ret_val = abupdate_binary_command(path, Zip, 0, pipe_fd[1], &args); + } else { + LOGERR("Unknown zip type %i\n", ztype); + ret_val = INSTALL_CORRUPT; + } + if (ret_val) { + close(pipe_fd[0]); + close(pipe_fd[1]); + return ret_val; + } + + // Convert the vector to a NULL-terminated char* array suitable for execv. + const char* chr_args[args.size() + 1]; + chr_args[args.size()] = NULL; + for (size_t i = 0; i < args.size(); i++) + chr_args[i] = args[i].c_str(); pid_t pid = fork(); if (pid == 0) { close(pipe_fd[0]); - execve(Temp_Binary.c_str(), (char* const*)args, environ); - printf("E:Can't execute '%s': %s\n", Temp_Binary.c_str(), strerror(errno)); - free(temp); + execve(chr_args[0], const_cast(chr_args), environ); + printf("E:Can't execute '%s': %s\n", chr_args[0], strerror(errno)); _exit(-1); } close(pipe_fd[1]); - free(temp); - temp = NULL; *wipe_cache = 0; @@ -341,16 +365,35 @@ extern "C" int TWinstall_zip(const char* path, int* wipe_cache) { sysReleaseMap(&map); return INSTALL_CORRUPT; } + time_t start, stop; time(&start); - ret_val = Run_Update_Binary(path, &Zip, wipe_cache); + const ZipEntry* file_location = mzFindZipEntry(&Zip, ASSUMED_UPDATE_BINARY_NAME); + if (file_location != NULL) { + LOGINFO("Update binary zip\n"); + ret_val = Prepare_Update_Binary(path, &Zip, wipe_cache); + if (ret_val == INSTALL_SUCCESS) + ret_val = Run_Update_Binary(path, &Zip, wipe_cache, UPDATE_BINARY_ZIP_TYPE); + } else { + file_location = mzFindZipEntry(&Zip, AB_OTA); + if (file_location != NULL) { + LOGINFO("AB zip\n"); + ret_val = Run_Update_Binary(path, &Zip, wipe_cache, AB_OTA_ZIP_TYPE); + } else { + file_location = mzFindZipEntry(&Zip, "ui.xml"); + if (file_location != NULL) { + LOGINFO("TWRP theme zip\n"); + ret_val = Install_Theme(path, &Zip); + } else { + mzCloseZipArchive(&Zip); + ret_val = INSTALL_CORRUPT; + } + } + } time(&stop); int total_time = (int) difftime(stop, start); if (ret_val == INSTALL_CORRUPT) { - // If no updater binary is found, check for ui.xml - ret_val = Install_Theme(path, &Zip); - if (ret_val == INSTALL_CORRUPT) - gui_msg(Msg(msg::kError, "no_updater_binary=Could not find '{1}' in the zip file.")(ASSUMED_UPDATE_BINARY_NAME)); + gui_err("invalid_zip_format=Invalid zip file format!"); } else { LOGINFO("Install took %i second(s).\n", total_time); }