Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0b58e9a0 authored by Tao Bao's avatar Tao Bao
Browse files

updater: Remove the support for sha1_check(). 

The matching edify function has been removed from EdifyGenerator [1]. In
theory device-specific releasetools script may still use this function,
but it no longer looks useful. Because a) we should use range_sha1()
when asserting the SHA-1 hash of a block device; b) we should look into
the contents when asserting a text file.

[1] https://android-review.googlesource.com/c/platform/build/+/714104

Test: Run recovery_component_test on marlin.
Test: Code search shows no active user.
Change-Id: Id39439101534fb89cf8c5cea80a4b758c8a1a60d
parent c059b6c1

tests/component/updater_test.cpp

+28 −33
Original line number Diff line number Diff line
@@ -72,7 +72,7 @@ static void expect(const char* expected, const char* expr_str, CauseCode cause_c 
  if (expected == nullptr) {

    ASSERT_FALSE(status);

  } else {

    ASSERT_TRUE(status);

    ASSERT_TRUE(status) << "Evaluate() finished with error message: " << state.errmsg;

    ASSERT_STREQ(expected, result.c_str());

  }
@@ -138,6 +138,25 @@ static std::string get_sha1(const std::string& content) { 
  return print_sha1(digest);

}



static Value* BlobToString(const char* name, State* state,

                           const std::vector<std::unique_ptr<Expr>>& argv) {

  if (argv.size() != 1) {

    return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %zu", name, argv.size());

  }



  std::vector<std::unique_ptr<Value>> args;

  if (!ReadValueArgs(state, argv, &args)) {

    return nullptr;

  }



  if (args[0]->type != VAL_BLOB) {

    return ErrorAbort(state, kArgsParsingFailure, "%s() expects a BLOB argument", name);

  }



  args[0]->type = VAL_STRING;

  return args[0].release();

}



class UpdaterTest : public ::testing::Test {

 protected:

  void SetUp() override {
@@ -145,6 +164,8 @@ class UpdaterTest : public ::testing::Test { 
    RegisterInstallFunctions();

    RegisterBlockImageFunctions();



    RegisterFunction("blob_to_string", BlobToString);



    // Each test is run in a separate process (isolated mode). Shared temporary files won't cause

    // conflicts.

    Paths::Get().set_cache_temp_source(temp_saved_source_.path);
@@ -192,33 +213,6 @@ TEST_F(UpdaterTest, getprop) { 
    expect(nullptr, "getprop(\"arg1\", \"arg2\")", kArgsParsingFailure);

}



TEST_F(UpdaterTest, sha1_check) {

    // sha1_check(data) returns the SHA-1 of the data.

    expect("81fe8bfe87576c3ecb22426f8e57847382917acf", "sha1_check(\"abcd\")", kNoCause);

    expect("da39a3ee5e6b4b0d3255bfef95601890afd80709", "sha1_check(\"\")", kNoCause);



    // sha1_check(data, sha1_hex, [sha1_hex, ...]) returns the matched SHA-1.

    expect("81fe8bfe87576c3ecb22426f8e57847382917acf",

           "sha1_check(\"abcd\", \"81fe8bfe87576c3ecb22426f8e57847382917acf\")",

           kNoCause);



    expect("81fe8bfe87576c3ecb22426f8e57847382917acf",

           "sha1_check(\"abcd\", \"wrong_sha1\", \"81fe8bfe87576c3ecb22426f8e57847382917acf\")",

           kNoCause);



    // Or "" if there's no match.

    expect("",

           "sha1_check(\"abcd\", \"wrong_sha1\")",

           kNoCause);



    expect("",

           "sha1_check(\"abcd\", \"wrong_sha1\", \"wrong_sha2\")",

           kNoCause);



    // sha1_check() expects at least one argument.

    expect(nullptr, "sha1_check()", kArgsParsingFailure);

}



TEST_F(UpdaterTest, apply_patch_check) {

  // Zero-argument is not valid.

  expect(nullptr, "apply_patch_check()", kArgsParsingFailure);
@@ -355,12 +349,13 @@ TEST_F(UpdaterTest, package_extract_file) { 
  script = "package_extract_file(\"a.txt\", \"/dev/full\")";

  expect("", script.c_str(), kNoCause, &updater_info);



  // One-argument version.

  script = "sha1_check(package_extract_file(\"a.txt\"))";

  expect(kATxtSha1Sum.c_str(), script.c_str(), kNoCause, &updater_info);

  // One-argument version. package_extract_file() gives a VAL_BLOB, which needs to be converted to

  // VAL_STRING for equality test.

  script = "blob_to_string(package_extract_file(\"a.txt\")) == \"" + kATxtContents + "\"";

  expect("t", script.c_str(), kNoCause, &updater_info);



  script = "sha1_check(package_extract_file(\"b.txt\"))";

  expect(kBTxtSha1Sum.c_str(), script.c_str(), kNoCause, &updater_info);

  script = "blob_to_string(package_extract_file(\"b.txt\")) == \"" + kBTxtContents + "\"";

  expect("t", script.c_str(), kNoCause, &updater_info);



  // Missing entry. The one-argument version aborts the evaluation.

  script = "package_extract_file(\"doesntexist\")";

updater/install.cpp

+1 −49
Original line number Diff line number Diff line
@@ -262,9 +262,7 @@ Value* ApplyPatchFn(const char* name, State* state, 
// apply_patch_check(filename, [sha1, ...])

//   Returns true if the contents of filename or the temporary copy in the cache partition (if

//   present) have a SHA-1 checksum equal to one of the given sha1 values. sha1 values are

//   specified as 40 hex digits. This function differs from sha1_check(read_file(filename),

//   sha1 [, ...]) in that it knows to check the cache partition copy, so apply_patch_check() will

//   succeed even if the file was corrupted by an interrupted apply_patch() update.

//   specified as 40 hex digits.

Value* ApplyPatchCheckFn(const char* name, State* state,

                         const std::vector<std::unique_ptr<Expr>>& argv) {

  if (argv.size() < 1) {
@@ -287,51 +285,6 @@ Value* ApplyPatchCheckFn(const char* name, State* state, 
  return StringValue(result == 0 ? "t" : "");

}



// sha1_check(data)

//    to return the sha1 of the data (given in the format returned by

//    read_file).

//

// sha1_check(data, sha1_hex, [sha1_hex, ...])

//    returns the sha1 of the file if it matches any of the hex

//    strings passed, or "" if it does not equal any of them.

//

Value* Sha1CheckFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv) {

  if (argv.size() < 1) {

    return ErrorAbort(state, kArgsParsingFailure, "%s() expects at least 1 arg", name);

  }



  std::vector<std::unique_ptr<Value>> args;

  if (!ReadValueArgs(state, argv, &args)) {

    return nullptr;

  }



  if (args[0]->type == VAL_INVALID) {

    return StringValue("");

  }

  uint8_t digest[SHA_DIGEST_LENGTH];

  SHA1(reinterpret_cast<const uint8_t*>(args[0]->data.c_str()), args[0]->data.size(), digest);



  if (argv.size() == 1) {

    return StringValue(print_sha1(digest));

  }



  for (size_t i = 1; i < argv.size(); ++i) {

    uint8_t arg_digest[SHA_DIGEST_LENGTH];

    if (args[i]->type != VAL_STRING) {

      LOG(ERROR) << name << "(): arg " << i << " is not a string; skipping";

    } else if (ParseSha1(args[i]->data, arg_digest) != 0) {

      // Warn about bad args and skip them.

      LOG(ERROR) << name << "(): error parsing \"" << args[i]->data << "\" as sha-1; skipping";

    } else if (memcmp(digest, arg_digest, SHA_DIGEST_LENGTH) == 0) {

      // Found a match.

      return args[i].release();

    }

  }



  // Didn't match any of the hex strings; return false.

  return StringValue("");

}



// mount(fs_type, partition_type, location, mount_point)

// mount(fs_type, partition_type, location, mount_point, mount_options)
@@ -1027,7 +980,6 @@ void RegisterInstallFunctions() { 
  RegisterFunction("wipe_block_device", WipeBlockDeviceFn);



  RegisterFunction("read_file", ReadFileFn);

  RegisterFunction("sha1_check", Sha1CheckFn);

  RegisterFunction("write_value", WriteValueFn);



  RegisterFunction("wipe_cache", WipeCacheFn);