idmap2/self_targeting/SelfTargeting.cpp

/*
 * Copyright (C) 2022 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 <sys/stat.h>

#include <fstream>
#include <optional>

#define LOG_TAG "SelfTargeting"

#include "androidfw/ResourceTypes.h"
#include "idmap2/BinaryStreamVisitor.h"
#include "idmap2/FabricatedOverlay.h"
#include "idmap2/Idmap.h"
#include "idmap2/Result.h"

using PolicyBitmask = android::ResTable_overlayable_policy_header::PolicyBitmask;
using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags;
using android::idmap2::BinaryStreamVisitor;
using android::idmap2::Idmap;
using android::idmap2::IdmapConstraints;
using android::idmap2::OverlayResourceContainer;

namespace android::self_targeting {

constexpr const mode_t kIdmapFilePermission = S_IRUSR | S_IWUSR;  // u=rw-, g=---, o=---

extern "C" bool
CreateFrroFile(std::string& out_err_result, const std::string& packageName,
               const std::string& overlayName, const std::string& targetPackageName,
               const std::optional<std::string>& targetOverlayable,
               const std::vector<FabricatedOverlayEntryParameters>& entries_params,
               const std::string& frro_file_path) {
    android::idmap2::FabricatedOverlay::Builder builder(packageName, overlayName,
                                                        targetPackageName);
    if (targetOverlayable.has_value()) {
        builder.SetOverlayable(targetOverlayable.value_or(std::string()));
    }
    for (const auto& entry_params : entries_params) {
        const auto dataType = entry_params.data_type;
        if (entry_params.data_binary_value.has_value()) {
            builder.SetResourceValue(entry_params.resource_name, *entry_params.data_binary_value,
                                     entry_params.binary_data_offset, entry_params.binary_data_size,
                                     entry_params.configuration, entry_params.nine_patch);
        } else  if (dataType >= Res_value::TYPE_FIRST_INT && dataType <= Res_value::TYPE_LAST_INT) {
           builder.SetResourceValue(entry_params.resource_name, dataType,
                                    entry_params.data_value, entry_params.configuration);
        } else if (dataType == Res_value::TYPE_STRING) {
           builder.SetResourceValue(entry_params.resource_name, dataType,
                                    entry_params.data_string_value , entry_params.configuration);
        } else {
            out_err_result = base::StringPrintf("Unsupported data type %d", dataType);
            return false;
        }
    }

    const auto frro = builder.Build();
    std::ofstream fout(frro_file_path);
    if (fout.fail()) {
        out_err_result = base::StringPrintf("open output stream fail %s", std::strerror(errno));
        return false;
    }
    auto result = frro->ToBinaryStream(fout);
    if (!result) {
        unlink(frro_file_path.c_str());
        out_err_result = base::StringPrintf("to stream fail %s", result.GetErrorMessage().c_str());
        return false;
    }
    fout.close();
    if (fout.fail()) {
        unlink(frro_file_path.c_str());
        out_err_result = base::StringPrintf("output stream fail %s", std::strerror(errno));
        return false;
    }
    if (chmod(frro_file_path.c_str(), kIdmapFilePermission) == -1) {
        out_err_result = base::StringPrintf("Failed to change the file permission %s",
                                            frro_file_path.c_str());
        return false;
    }
    return true;
}

static PolicyBitmask GetFulfilledPolicy(const bool isSystem, const bool isVendor,
                                        const bool isProduct, const bool isTargetSignature,
                                        const bool isOdm, const bool isOem) {
    auto fulfilled_policy = static_cast<PolicyBitmask>(PolicyFlags::PUBLIC);

    if (isSystem) {
        fulfilled_policy |= PolicyFlags::SYSTEM_PARTITION;
    }
    if (isVendor) {
        fulfilled_policy |= PolicyFlags::VENDOR_PARTITION;
    }
    if (isProduct) {
        fulfilled_policy |= PolicyFlags::PRODUCT_PARTITION;
    }
    if (isOdm) {
        fulfilled_policy |= PolicyFlags::ODM_PARTITION;
    }
    if (isOem) {
        fulfilled_policy |= PolicyFlags::OEM_PARTITION;
    }
    if (isTargetSignature) {
        fulfilled_policy |= PolicyFlags::SIGNATURE;
    }

    // Not support actor_signature and config_overlay_signature
    fulfilled_policy &=
            ~(PolicyFlags::ACTOR_SIGNATURE | PolicyFlags::CONFIG_SIGNATURE);

    ALOGV(
            "fulfilled_policy = 0x%08x, isSystem = %d, isVendor = %d, isProduct = %d,"
            " isTargetSignature = %d, isOdm = %d, isOem = %d,",
            fulfilled_policy, isSystem, isVendor, isProduct, isTargetSignature, isOdm, isOem);
    return fulfilled_policy;
}

extern "C" bool
CreateIdmapFile(std::string& out_err, const std::string& targetPath, const std::string& overlayPath,
                const std::string& idmapPath, const std::string& overlayName,
                const bool isSystem, const bool isVendor, const bool isProduct,
                const bool isTargetSignature, const bool isOdm, const bool isOem) {
    // idmap files are mapped with mmap in libandroidfw. Deleting and recreating the idmap
    // guarantees that existing memory maps will continue to be valid and unaffected. The file must
    // be deleted before attempting to create the idmap, so that if idmap  creation fails, the
    // overlay will no longer be usable.
    unlink(idmapPath.c_str());

    const auto target = idmap2::TargetResourceContainer::FromPath(targetPath);
    if (!target) {
        out_err = base::StringPrintf("Failed to load target %s because of %s", targetPath.c_str(),
                                     target.GetErrorMessage().c_str());
        return false;
    }

    const auto overlay = OverlayResourceContainer::FromPath(overlayPath);
    if (!overlay) {
        out_err = base::StringPrintf("Failed to load overlay %s because of %s", overlayPath.c_str(),
                                     overlay.GetErrorMessage().c_str());
        return false;
    }

    // Overlay self target process. Only allow self-targeting types.
    const auto fulfilled_policies = GetFulfilledPolicy(isSystem, isVendor, isProduct,
                                                       isTargetSignature, isOdm, isOem);
    auto constraints = std::make_unique<const IdmapConstraints>();
    const auto idmap = Idmap::FromContainers(**target, **overlay, overlayName,
                                             fulfilled_policies, true /* enforce_overlayable */,
                                             std::move(constraints));
    if (!idmap) {
        out_err = base::StringPrintf("Failed to create idmap because of %s",
                                     idmap.GetErrorMessage().c_str());
        return false;
    }

    std::ofstream fout(idmapPath.c_str());
    if (fout.fail()) {
        out_err = base::StringPrintf("Failed to create idmap %s because of %s", idmapPath.c_str(),
                                     strerror(errno));
        return false;
    }

    BinaryStreamVisitor visitor(fout);
    (*idmap)->accept(&visitor);
    fout.close();
    if (fout.fail()) {
        unlink(idmapPath.c_str());
        out_err = base::StringPrintf("Failed to write idmap %s because of %s", idmapPath.c_str(),
                                     strerror(errno));
        return false;
    }
    if (chmod(idmapPath.c_str(), kIdmapFilePermission) == -1) {
        out_err = base::StringPrintf("Failed to change the file permission %s", idmapPath.c_str());
        return false;
    }
    return true;
}

extern "C" bool
GetFabricatedOverlayInfo(std::string& out_err, const std::string& overlay_path,
                         OverlayManifestInfo& out_info) {
    const auto overlay = idmap2::FabricatedOverlayContainer::FromPath(overlay_path);
    if (!overlay) {
        out_err = base::StringPrintf("Failed to write idmap %s because of %s",
                                     overlay_path.c_str(), strerror(errno));
        return false;
    }

    out_info = (*overlay)->GetManifestInfo();

    return true;
}

}  // namespace android::self_targeting