utils/shell-as/test-app.cpp

/*
 * Copyright (C) 2023 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 "./test-app.h"

#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#include <iostream>
#include <string>

#include "./string-utils.h"

namespace shell_as {

// Returns a pointer to bytes of the test app APK along with the length in bytes
// of the APK.
//
// This function is defined by the shell-as-test-app-apk-cpp genrule.
void GetTestApk(uint8_t **apk, size_t *length);

namespace {

// The staging path for the test app APK.
const char kTestAppApkStagingPath[] = "/data/local/tmp/shell-as-test-app.apk";

// Writes the test app to a staging location and then installs the APK via the
// 'pm' utility. The app is granted runtime permissions on installation. Returns
// true if the app is installed successfully.
bool InstallTestApp() {
  uint8_t *apk = nullptr;
  size_t apk_size = 0;
  GetTestApk(&apk, &apk_size);

  int staging_file = open(kTestAppApkStagingPath, O_WRONLY | O_CREAT | O_TRUNC,
                          S_IRUSR | S_IWUSR);
  if (staging_file == -1) {
    std::cerr << "Unable to open staging APK path." << std::endl;
    return false;
  }

  size_t bytes_written = write(staging_file, apk, apk_size);
  close(staging_file);
  if (bytes_written != apk_size) {
    std::cerr << "Unable to write entire test app APK." << std::endl;
    return false;
  }

  const char cmd_template[] = "pm install -g %s > /dev/null 2> /dev/null";
  char system_cmd[sizeof(cmd_template) + sizeof(kTestAppApkStagingPath) + 1] =
      {};
  sprintf(system_cmd, cmd_template, kTestAppApkStagingPath);
  return system(system_cmd) == 0;
}

// Uninstalls the test app if it is installed. This method is a no-op if the app
// is not installed.
void UninstallTestApp() {
  system(
      "pm uninstall com.android.google.tools.security.shell_as"
      " > /dev/null 2> /dev/null");
}

// Starts the main activity of the test app. This is necessary as some aspects
// of the security context can only be inferred from a running process.
bool StartTestApp() {
  return system(
             "am start-activity "
             "com.android.google.tools.security.shell_as/"
             ".MainActivity"
             " > /dev/null 2> /dev/null") == 0;
}

// Obtain the process ID of the test app and returns true if it is running.
// Returns false otherwise.
bool GetTestAppProcessId(pid_t *test_app_pid) {
  FILE *pgrep = popen(
      "pgrep -f "
      "com.android.google.tools.security.shell_as",
      "r");
  if (!pgrep) {
    std::cerr << "Unable to execute pgrep." << std::endl;
    return false;
  }

  char pgrep_output[128];
  memset(pgrep_output, 0, sizeof(pgrep_output));
  int bytes_read = fread(pgrep_output, 1, sizeof(pgrep_output) - 1, pgrep);
  pclose(pgrep);
  if (bytes_read <= 0) {
    // Unable to find the process. This may happen if the app is still starting
    // up.
    return false;
  }
  return StringToUInt32(pgrep_output, (uint32_t *)test_app_pid);
}
}  // namespace

bool SetupAndStartTestApp(pid_t *test_app_pid) {
  UninstallTestApp();

  if (!InstallTestApp()) {
    std::cerr << "Unable to install test app." << std::endl;
    return false;
  }

  if (!StartTestApp()) {
    std::cerr << "Unable to start and obtain test app PID." << std::endl;
    return false;
  }

  for (int i = 0; i < 5; i++) {
    if (GetTestAppProcessId(test_app_pid)) {
      return true;
    }
    sleep(1);
  }
  return false;
}
}  // namespace shell_as