/*
* Copyright (C) 2018 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.
*/
/*
* The tests in this file operate on a higher level than the tests in the other
* files. Here, all tests execute the idmap2 binary and only depend on
* libidmap2 to verify the output of idmap2.
*/
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <cerrno>
#include <cstdlib>
#include <cstring> // strerror
#include <fstream>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include "TestHelpers.h"
#include "androidfw/PosixUtils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "idmap2/FileUtils.h"
#include "idmap2/Idmap.h"
#include "private/android_filesystem_config.h"
using ::android::util::ExecuteBinary;
using ::testing::NotNull;
namespace android::idmap2 {
class Idmap2BinaryTests : public Idmap2Tests {};
namespace {
void AssertIdmap(const Idmap& idmap, const std::string& target_apk_path,
const std::string& overlay_apk_path) {
// check that the idmap file looks reasonable (IdmapTests is responsible for
// more in-depth verification)
ASSERT_EQ(idmap.GetHeader()->GetMagic(), kIdmapMagic);
ASSERT_EQ(idmap.GetHeader()->GetVersion(), kIdmapCurrentVersion);
ASSERT_EQ(idmap.GetHeader()->GetTargetPath(), target_apk_path);
ASSERT_EQ(idmap.GetHeader()->GetOverlayPath(), overlay_apk_path);
ASSERT_EQ(idmap.GetData().size(), 1U);
}
#define ASSERT_IDMAP(idmap_ref, target_apk_path, overlay_apk_path) \
do { \
ASSERT_NO_FATAL_FAILURE(AssertIdmap(idmap_ref, target_apk_path, overlay_apk_path)); \
} while (0)
#ifdef __ANDROID__
#define SKIP_TEST_IF_CANT_EXEC_IDMAP2 \
do { \
const uid_t uid = getuid(); \
if (uid != AID_ROOT && uid != AID_SYSTEM) { \
GTEST_SKIP(); \
} \
} while (0)
#else
#define SKIP_TEST_IF_CANT_EXEC_IDMAP2
#endif
} // namespace
TEST_F(Idmap2BinaryTests, Create) {
SKIP_TEST_IF_CANT_EXEC_IDMAP2;
// clang-format off
auto result = ExecuteBinary({"idmap2",
"create",
"--target-apk-path", GetTargetApkPath(),
"--overlay-apk-path", GetOverlayApkPath(),
"--idmap-path", GetIdmapPath()});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
struct stat st;
ASSERT_EQ(stat(GetIdmapPath().c_str(), &st), 0);
std::ifstream fin(GetIdmapPath());
const auto idmap = Idmap::FromBinaryStream(fin);
fin.close();
ASSERT_TRUE(idmap);
ASSERT_IDMAP(**idmap, GetTargetApkPath(), GetOverlayApkPath());
unlink(GetIdmapPath().c_str());
}
TEST_F(Idmap2BinaryTests, Dump) {
SKIP_TEST_IF_CANT_EXEC_IDMAP2;
// clang-format off
auto result = ExecuteBinary({"idmap2",
"create",
"--target-apk-path", GetTargetApkPath(),
"--overlay-apk-path", GetOverlayApkPath(),
"--idmap-path", GetIdmapPath()});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
// clang-format off
result = ExecuteBinary({"idmap2",
"dump",
"--idmap-path", GetIdmapPath()});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
ASSERT_NE(result->stdout.find("0x7f010000 -> 0x7f010000 integer/int1"), std::string::npos);
ASSERT_NE(result->stdout.find("0x7f02000c -> 0x7f020000 string/str1"), std::string::npos);
ASSERT_NE(result->stdout.find("0x7f02000e -> 0x7f020001 string/str3"), std::string::npos);
ASSERT_NE(result->stdout.find("0x7f02000f -> 0x7f020002 string/str4"), std::string::npos);
ASSERT_EQ(result->stdout.find("00000210: 007f target package id"), std::string::npos);
// clang-format off
result = ExecuteBinary({"idmap2",
"dump",
"--verbose",
"--idmap-path", GetIdmapPath()});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
ASSERT_NE(result->stdout.find("00000000: 504d4449 magic"), std::string::npos);
ASSERT_NE(result->stdout.find("00000210: 007f target package id"), std::string::npos);
// clang-format off
result = ExecuteBinary({"idmap2",
"dump",
"--verbose",
"--idmap-path", GetTestDataPath() + "/DOES-NOT-EXIST"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_NE(result->status, EXIT_SUCCESS);
unlink(GetIdmapPath().c_str());
}
TEST_F(Idmap2BinaryTests, Scan) {
SKIP_TEST_IF_CANT_EXEC_IDMAP2;
const std::string overlay_static_no_name_apk_path =
GetTestDataPath() + "/overlay/overlay-no-name-static.apk";
const std::string overlay_static_1_apk_path = GetTestDataPath() + "/overlay/overlay-static-1.apk";
const std::string overlay_static_2_apk_path = GetTestDataPath() + "/overlay/overlay-static-2.apk";
const std::string idmap_static_no_name_path =
Idmap::CanonicalIdmapPathFor(GetTempDirPath(), overlay_static_no_name_apk_path);
const std::string idmap_static_1_path =
Idmap::CanonicalIdmapPathFor(GetTempDirPath(), overlay_static_1_apk_path);
const std::string idmap_static_2_path =
Idmap::CanonicalIdmapPathFor(GetTempDirPath(), overlay_static_2_apk_path);
// single input directory, recursive
// clang-format off
auto result = ExecuteBinary({"idmap2",
"scan",
"--input-directory", GetTestDataPath(),
"--recursive",
"--target-package-name", "test.target",
"--target-apk-path", GetTargetApkPath(),
"--output-directory", GetTempDirPath(),
"--override-policy", "public"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
std::stringstream expected;
expected << idmap_static_no_name_path << std::endl;
expected << idmap_static_1_path << std::endl;
expected << idmap_static_2_path << std::endl;
ASSERT_EQ(result->stdout, expected.str());
auto idmap_static_no_name_raw_string = utils::ReadFile(idmap_static_no_name_path);
auto idmap_static_no_name_raw_stream = std::istringstream(*idmap_static_no_name_raw_string);
auto idmap_static_no_name = Idmap::FromBinaryStream(idmap_static_no_name_raw_stream);
ASSERT_TRUE(idmap_static_no_name);
ASSERT_IDMAP(**idmap_static_no_name, GetTargetApkPath(), overlay_static_no_name_apk_path);
auto idmap_static_1_raw_string = utils::ReadFile(idmap_static_1_path);
auto idmap_static_1_raw_stream = std::istringstream(*idmap_static_1_raw_string);
auto idmap_static_1 = Idmap::FromBinaryStream(idmap_static_1_raw_stream);
ASSERT_TRUE(idmap_static_1);
ASSERT_IDMAP(**idmap_static_1, GetTargetApkPath(), overlay_static_1_apk_path);
auto idmap_static_2_raw_string = utils::ReadFile(idmap_static_2_path);
auto idmap_static_2_raw_stream = std::istringstream(*idmap_static_2_raw_string);
auto idmap_static_2 = Idmap::FromBinaryStream(idmap_static_2_raw_stream);
ASSERT_TRUE(idmap_static_2);
ASSERT_IDMAP(**idmap_static_2, GetTargetApkPath(), overlay_static_2_apk_path);
unlink(idmap_static_no_name_path.c_str());
unlink(idmap_static_2_path.c_str());
unlink(idmap_static_1_path.c_str());
// multiple input directories, non-recursive
// clang-format off
result = ExecuteBinary({"idmap2",
"scan",
"--input-directory", GetTestDataPath() + "/target",
"--input-directory", GetTestDataPath() + "/overlay",
"--target-package-name", "test.target",
"--target-apk-path", GetTargetApkPath(),
"--output-directory", GetTempDirPath(),
"--override-policy", "public"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
ASSERT_EQ(result->stdout, expected.str());
unlink(idmap_static_no_name_path.c_str());
unlink(idmap_static_2_path.c_str());
unlink(idmap_static_1_path.c_str());
// the same input directory given twice, but no duplicate entries
// clang-format off
result = ExecuteBinary({"idmap2",
"scan",
"--input-directory", GetTestDataPath(),
"--input-directory", GetTestDataPath(),
"--recursive",
"--target-package-name", "test.target",
"--target-apk-path", GetTargetApkPath(),
"--output-directory", GetTempDirPath(),
"--override-policy", "public"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
ASSERT_EQ(result->stdout, expected.str());
unlink(idmap_static_no_name_path.c_str());
unlink(idmap_static_2_path.c_str());
unlink(idmap_static_1_path.c_str());
// no APKs in input-directory: ok, but no output
// clang-format off
result = ExecuteBinary({"idmap2",
"scan",
"--input-directory", GetTempDirPath(),
"--target-package-name", "test.target",
"--target-apk-path", GetTargetApkPath(),
"--output-directory", GetTempDirPath(),
"--override-policy", "public"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
ASSERT_EQ(result->stdout, "");
// the signature idmap failing to generate should not cause scanning to fail
// clang-format off
result = ExecuteBinary({"idmap2",
"scan",
"--input-directory", GetTestDataPath(),
"--recursive",
"--target-package-name", "test.target",
"--target-apk-path", GetTargetApkPath(),
"--output-directory", GetTempDirPath(),
"--override-policy", "public"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
ASSERT_EQ(result->stdout, expected.str());
unlink(idmap_static_no_name_path.c_str());
unlink(idmap_static_2_path.c_str());
unlink(idmap_static_1_path.c_str());
}
TEST_F(Idmap2BinaryTests, Lookup) {
SKIP_TEST_IF_CANT_EXEC_IDMAP2;
// clang-format off
auto result = ExecuteBinary({"idmap2",
"create",
"--target-apk-path", GetTargetApkPath(),
"--overlay-apk-path", GetOverlayApkPath(),
"--idmap-path", GetIdmapPath()});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
// clang-format off
result = ExecuteBinary({"idmap2",
"lookup",
"--idmap-path", GetIdmapPath(),
"--config", "",
"--resid", "0x7f02000c"}); // string/str1
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
ASSERT_NE(result->stdout.find("overlay-1"), std::string::npos);
ASSERT_EQ(result->stdout.find("overlay-1-sv"), std::string::npos);
// clang-format off
result = ExecuteBinary({"idmap2",
"lookup",
"--idmap-path", GetIdmapPath(),
"--config", "",
"--resid", "test.target:string/str1"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
ASSERT_NE(result->stdout.find("overlay-1"), std::string::npos);
ASSERT_EQ(result->stdout.find("overlay-1-sv"), std::string::npos);
// clang-format off
result = ExecuteBinary({"idmap2",
"lookup",
"--idmap-path", GetIdmapPath(),
"--config", "sv",
"--resid", "test.target:string/str1"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_EQ(result->status, EXIT_SUCCESS) << result->stderr;
ASSERT_NE(result->stdout.find("overlay-1-sv"), std::string::npos);
unlink(GetIdmapPath().c_str());
}
TEST_F(Idmap2BinaryTests, InvalidCommandLineOptions) {
SKIP_TEST_IF_CANT_EXEC_IDMAP2;
const std::string invalid_target_apk_path = GetTestDataPath() + "/DOES-NOT-EXIST";
// missing mandatory options
// clang-format off
auto result = ExecuteBinary({"idmap2",
"create"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_NE(result->status, EXIT_SUCCESS);
// missing argument to option
// clang-format off
result = ExecuteBinary({"idmap2",
"create",
"--target-apk-path", GetTargetApkPath(),
"--overlay-apk-path", GetOverlayApkPath(),
"--idmap-path"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_NE(result->status, EXIT_SUCCESS);
// invalid target apk path
// clang-format off
result = ExecuteBinary({"idmap2",
"create",
"--target-apk-path", invalid_target_apk_path,
"--overlay-apk-path", GetOverlayApkPath(),
"--idmap-path", GetIdmapPath()});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_NE(result->status, EXIT_SUCCESS);
// unknown policy
// clang-format off
result = ExecuteBinary({"idmap2",
"create",
"--target-apk-path", GetTargetApkPath(),
"--overlay-apk-path", GetOverlayApkPath(),
"--idmap-path", GetIdmapPath(),
"--policy", "this-does-not-exist"});
// clang-format on
ASSERT_THAT(result, NotNull());
ASSERT_NE(result->status, EXIT_SUCCESS);
}
} // namespace android::idmap2