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

Commit ef28554d authored by Shawn Willden's avatar Shawn Willden
Browse files

Update Keymaster 4.0 VTS to use parameterized tests. 

Bug: 139437880
Test: VtsHalKeyamsterV4_0TargetTest
Change-Id: I487000cc19fe355fdef88f1561a38b2cbfd3c3c3
Merged-In: I487000cc19fe355fdef88f1561a38b2cbfd3c3c3
parent fcc4c5c7

keymaster/4.0/vts/functional/HmacKeySharingTest.cpp

+42 −28
Original line number Diff line number Diff line
@@ -28,6 +28,16 @@ namespace test { 
 */

class HmacKeySharingTest : public KeymasterHidlTest {

   protected:

     const std::vector<sp<IKeymasterDevice>>& allKeymasters() {

         if (all_keymasters_.empty()) {

             auto names = android::hardware::getAllHalInstanceNames(IKeymasterDevice::descriptor);

             for (const auto& name : names) {

                 all_keymasters_.push_back(IKeymasterDevice::getService(name));

             }

         }

         return all_keymasters_;

     }



    struct GetParamsResult {

        ErrorCode error;

        HmacSharingParameters params;
@@ -99,8 +109,13 @@ class HmacKeySharingTest : public KeymasterHidlTest { 
            EXPECT_EQ(expected, response.sharing_check) << "Sharing check values should match.";

        }

    }



  private:

    static std::vector<sp<IKeymasterDevice>> all_keymasters_;

};



std::vector<sp<IKeymasterDevice>> HmacKeySharingTest::all_keymasters_;



TEST_P(HmacKeySharingTest, GetParameters) {

    auto result1 = getHmacSharingParameters(keymaster());

    EXPECT_EQ(ErrorCode::OK, result1.error);
@@ -115,26 +130,26 @@ TEST_P(HmacKeySharingTest, GetParameters) { 
}



TEST_P(HmacKeySharingTest, ComputeSharedHmac) {

    auto params = getHmacSharingParameters(all_keymasters());

    ASSERT_EQ(all_keymasters().size(), params.size())

    auto params = getHmacSharingParameters(allKeymasters());

    ASSERT_EQ(allKeymasters().size(), params.size())

            << "One or more keymasters failed to provide parameters.";



    auto nonces = copyNonces(params);

    EXPECT_EQ(all_keymasters().size(), nonces.size());

    EXPECT_EQ(allKeymasters().size(), nonces.size());

    std::sort(nonces.begin(), nonces.end());

    std::unique(nonces.begin(), nonces.end());

    EXPECT_EQ(all_keymasters().size(), nonces.size());

    EXPECT_EQ(allKeymasters().size(), nonces.size());



    auto responses = computeSharedHmac(all_keymasters(), params);

    auto responses = computeSharedHmac(allKeymasters(), params);

    ASSERT_GT(responses.size(), 0U);

    verifyResponses(responses[0].sharing_check, responses);



    // Do it a second time.  Should get the same answers.

    params = getHmacSharingParameters(all_keymasters());

    ASSERT_EQ(all_keymasters().size(), params.size())

    params = getHmacSharingParameters(allKeymasters());

    ASSERT_EQ(allKeymasters().size(), params.size())

            << "One or more keymasters failed to provide parameters.";



    responses = computeSharedHmac(all_keymasters(), params);

    responses = computeSharedHmac(allKeymasters(), params);

    ASSERT_GT(responses.size(), 0U);

    ASSERT_EQ(32U, responses[0].sharing_check.size());

    verifyResponses(responses[0].sharing_check, responses);
@@ -160,15 +175,16 @@ TEST_P(HmacKeySharingTest, ComputeSharedHmacCorruptNonce) { 
    // sync with respect to the HMAC key.  Granted that VTS tests aren't run on in-use production

    // devices, this still has the potential to cause confusion.  To mitigate that, we always

    // (barring crashes :-/) re-run the unmodified agreement process on our way out.

    auto fixup_hmac = finally(

        [&]() { computeSharedHmac(all_keymasters(), getHmacSharingParameters(all_keymasters())); });

    auto fixup_hmac = finally([&]() {

        computeSharedHmac(allKeymasters(), getHmacSharingParameters(allKeymasters()));

    });



    auto params = getHmacSharingParameters(all_keymasters());

    ASSERT_EQ(all_keymasters().size(), params.size())

    auto params = getHmacSharingParameters(allKeymasters());

    ASSERT_EQ(allKeymasters().size(), params.size())

            << "One or more keymasters failed to provide parameters.";



    // All should be well in the normal case

    auto responses = computeSharedHmac(all_keymasters(), params);

    auto responses = computeSharedHmac(allKeymasters(), params);



    ASSERT_GT(responses.size(), 0U);

    HidlBuf correct_response = responses[0].sharing_check;
@@ -181,7 +197,7 @@ TEST_P(HmacKeySharingTest, ComputeSharedHmacCorruptNonce) { 
    uint8_t bit_to_tweak = rand() % 8;

    params[param_to_tweak].nonce[byte_to_tweak] ^= (1 << bit_to_tweak);



    responses = computeSharedHmac(all_keymasters(), params);

    responses = computeSharedHmac(allKeymasters(), params);

    for (size_t i = 0; i < responses.size(); ++i) {

        if (i == param_to_tweak) {

            EXPECT_EQ(ErrorCode::INVALID_ARGUMENT, responses[i].error)
@@ -199,15 +215,16 @@ TEST_P(HmacKeySharingTest, ComputeSharedHmacCorruptSeed) { 
    // sync with respect to the HMAC key.  Granted that VTS tests aren't run on in-use production

    // devices, this still has the potential to cause confusion.  To mitigate that, we always

    // (barring crashes :-/) re-run the unmodified agreement process on our way out.

    auto fixup_hmac = finally(

        [&]() { computeSharedHmac(all_keymasters(), getHmacSharingParameters(all_keymasters())); });

    auto fixup_hmac = finally([&]() {

        computeSharedHmac(allKeymasters(), getHmacSharingParameters(allKeymasters()));

    });



    auto params = getHmacSharingParameters(all_keymasters());

    ASSERT_EQ(all_keymasters().size(), params.size())

    auto params = getHmacSharingParameters(allKeymasters());

    ASSERT_EQ(allKeymasters().size(), params.size())

            << "One or more keymasters failed to provide parameters.";



    // All should be well in the normal case

    auto responses = computeSharedHmac(all_keymasters(), params);

    auto responses = computeSharedHmac(allKeymasters(), params);



    ASSERT_GT(responses.size(), 0U);

    HidlBuf correct_response = responses[0].sharing_check;
@@ -223,7 +240,7 @@ TEST_P(HmacKeySharingTest, ComputeSharedHmacCorruptSeed) { 
    }

    to_tweak[0]++;



    responses = computeSharedHmac(all_keymasters(), params);

    responses = computeSharedHmac(allKeymasters(), params);

    for (size_t i = 0; i < responses.size(); ++i) {

        if (i == param_to_tweak) {

            EXPECT_EQ(ErrorCode::INVALID_ARGUMENT, responses[i].error)
@@ -236,10 +253,7 @@ TEST_P(HmacKeySharingTest, ComputeSharedHmacCorruptSeed) { 
    }

}



INSTANTIATE_TEST_SUITE_P(

        PerInstance, HmacKeySharingTest,

        testing::ValuesIn(android::hardware::getAllHalInstanceNames(IKeymasterDevice::descriptor)),

        android::hardware::PrintInstanceNameToString);

INSTANTIATE_KEYMASTER_HIDL_TEST(HmacKeySharingTest);



}  // namespace test

}  // namespace V4_0

keymaster/4.0/vts/functional/KeymasterHidlTest.cpp

+11 −23
Original line number Diff line number Diff line
@@ -42,9 +42,10 @@ namespace V4_0 { 


namespace test {



using namespace std::literals::chrono_literals;



void KeymasterHidlTest::InitializeKeymaster() {

    service_name_ = GetParam();

    keymaster_ = IKeymasterDevice::getService(service_name_);

    keymaster_ = IKeymasterDevice::getService(GetParam());

    ASSERT_NE(keymaster_, nullptr);



    ASSERT_TRUE(keymaster_
@@ -57,24 +58,11 @@ void KeymasterHidlTest::InitializeKeymaster() { 
                        .isOk());

}



void KeymasterHidlTest::SetUpTestCase() {

void KeymasterHidlTest::SetUp() {

    InitializeKeymaster();



    os_version_ = support::getOsVersion();

    os_patch_level_ = support::getOsPatchlevel();



    auto service_manager = android::hidl::manager::V1_0::IServiceManager::getService();

    ASSERT_NE(nullptr, service_manager.get());

    all_keymasters_.push_back(keymaster_);

    service_manager->listByInterface(

        IKeymasterDevice::descriptor, [&](const hidl_vec<hidl_string>& names) {

            for (auto& name : names) {

                if (name == service_name_) continue;

                auto keymaster = IKeymasterDevice::getService(name);

                ASSERT_NE(keymaster, nullptr);

                all_keymasters_.push_back(keymaster);

            }

        });

}



ErrorCode KeymasterHidlTest::GenerateKey(const AuthorizationSet& key_desc, HidlBuf* key_blob,

keymaster/4.0/vts/functional/KeymasterHidlTest.h

+19 −18
Original line number Diff line number Diff line
@@ -18,8 +18,9 @@ 


#include <android/hardware/keymaster/4.0/IKeymasterDevice.h>

#include <android/hardware/keymaster/4.0/types.h>



#include <VtsHalHidlTargetTestBase.h>

#include <gtest/gtest.h>

#include <hidl/GtestPrinter.h>

#include <hidl/ServiceManagement.h>



#include <keymasterV4_0/authorization_set.h>
@@ -33,8 +34,8 @@ namespace V4_0 { 
namespace test {



using ::android::sp;

using ::std::string;

using hidl::base::V1_0::DebugInfo;

using ::std::string;



class HidlBuf : public hidl_vec<uint8_t> {

    typedef hidl_vec<uint8_t> super;
@@ -68,20 +69,16 @@ constexpr uint64_t kOpHandleSentinel = 0xFFFFFFFFFFFFFFFF; 


class KeymasterHidlTest : public ::testing::TestWithParam<std::string> {

  public:

    void SetUp();

    void SetUp() override;

    void TearDown() override {

        if (key_blob_.size()) {

            CheckedDeleteKey();

        }

        AbortIfNeeded();

        keymaster_.clear();

        all_keymasters_.clear();

    }



    void InitializeKeymaster();



    IKeymasterDevice& keymaster() { return *keymaster_; }

    const std::vector<sp<IKeymasterDevice>>& all_keymasters() { return all_keymasters_; }

    uint32_t os_version() { return os_version_; }

    uint32_t os_patch_level() { return os_patch_level_; }
@@ -209,16 +206,20 @@ class KeymasterHidlTest : public ::testing::TestWithParam<std::string> { 


  private:

    sp<IKeymasterDevice> keymaster_;

     std::vector<sp<IKeymasterDevice>> all_keymasters_;

    uint32_t os_version_;

    uint32_t os_patch_level_;



    SecurityLevel securityLevel_;

    hidl_string name_;

    hidl_string author_;

     string service_name_;

};



#define INSTANTIATE_KEYMASTER_HIDL_TEST(name)                                             \

    INSTANTIATE_TEST_SUITE_P(PerInstance, name,                                           \

                             testing::ValuesIn(android::hardware::getAllHalInstanceNames( \

                                     IKeymasterDevice::descriptor)),                      \

                             android::hardware::PrintInstanceNameToString)



}  // namespace test

}  // namespace V4_0

}  // namespace keymaster

keymaster/4.0/vts/functional/VerificationTokenTest.cpp

+1 −4
Original line number Diff line number Diff line
@@ -185,10 +185,7 @@ TEST_P(VerificationTokenTest, MacChangesOnChangingTimestamp) { 
              memcmp(result1.token.mac.data(), result2.token.mac.data(), result1.token.mac.size()));

}



INSTANTIATE_TEST_SUITE_P(

        PerInstance, VerificationTokenTest,

        testing::ValuesIn(android::hardware::getAllHalInstanceNames(IKeymasterDevice::descriptor)),

        android::hardware::PrintInstanceNameToString);

INSTANTIATE_KEYMASTER_HIDL_TEST(VerificationTokenTest);



}  // namespace test

}  // namespace V4_0

keymaster/4.0/vts/functional/keymaster_hidl_hal_test.cpp

+27 −38
Original line number Diff line number Diff line
@@ -840,6 +840,8 @@ TEST_P(NewKeyGenerationTest, HmacDigestNone) { 
                              .Authorization(TAG_MIN_MAC_LENGTH, 128)));

}



INSTANTIATE_KEYMASTER_HIDL_TEST(NewKeyGenerationTest);



typedef KeymasterHidlTest SigningOperationsTest;



/*
@@ -1509,6 +1511,8 @@ TEST_P(SigningOperationsTest, HmacRfc4231TestCase5) { 
    }

}



INSTANTIATE_KEYMASTER_HIDL_TEST(SigningOperationsTest);



typedef KeymasterHidlTest VerificationOperationsTest;



/*
@@ -1749,6 +1753,8 @@ TEST_P(VerificationOperationsTest, HmacSigningKeyCannotVerify) { 
    CheckedDeleteKey(&verification_key);

}



INSTANTIATE_KEYMASTER_HIDL_TEST(VerificationOperationsTest);



typedef KeymasterHidlTest ExportKeyTest;



/*
@@ -1828,6 +1834,8 @@ TEST_P(ExportKeyTest, AesKeyUnexportable) { 
    EXPECT_EQ(ErrorCode::UNSUPPORTED_KEY_FORMAT, ExportKey(KeyFormat::RAW, &export_data));

}



INSTANTIATE_KEYMASTER_HIDL_TEST(ExportKeyTest);



class ImportKeyTest : public KeymasterHidlTest {

   public:

    template <TagType tag_type, Tag tag, typename ValueT>
@@ -2093,6 +2101,8 @@ TEST_P(ImportKeyTest, HmacKeySuccess) { 
    VerifyMessage(message, signature, AuthorizationSetBuilder().Digest(Digest::SHA_2_256));

}



INSTANTIATE_KEYMASTER_HIDL_TEST(ImportKeyTest);



auto wrapped_key = hex2str(

    "3082017902010004820100934bf94e2aa28a3f83c9f79297250262fbe3276b5a1c91159bbfa3ef8957aac84b59b30b"

    "455a79c2973480823d8b3863c3deef4a8e243590268d80e18751a0e130f67ce6a1ace9f79b95e097474febc981195b"
@@ -2214,6 +2224,8 @@ TEST_P(ImportWrappedKeyTest, WrongPurpose) { 
                      .Padding(PaddingMode::RSA_OAEP)));

}



INSTANTIATE_KEYMASTER_HIDL_TEST(ImportWrappedKeyTest);



typedef KeymasterHidlTest EncryptionOperationsTest;



/*
@@ -4111,6 +4123,8 @@ TEST_P(EncryptionOperationsTest, TripleDesCbcIncrementalNoPadding) { 
    EXPECT_EQ(message, plaintext);

}



INSTANTIATE_KEYMASTER_HIDL_TEST(EncryptionOperationsTest);



typedef KeymasterHidlTest MaxOperationsTest;



/*
@@ -4166,6 +4180,8 @@ TEST_P(MaxOperationsTest, TestLimitRsa) { 
    EXPECT_EQ(ErrorCode::KEY_MAX_OPS_EXCEEDED, Begin(KeyPurpose::SIGN, params));

}



INSTANTIATE_KEYMASTER_HIDL_TEST(MaxOperationsTest);



typedef KeymasterHidlTest AddEntropyTest;



/*
@@ -4196,6 +4212,8 @@ TEST_P(AddEntropyTest, AddLargeEntropy) { 
    EXPECT_EQ(ErrorCode::OK, keymaster().addRngEntropy(HidlBuf(string(2 * 1024, 'a'))));

}



INSTANTIATE_KEYMASTER_HIDL_TEST(AddEntropyTest);



typedef KeymasterHidlTest AttestationTest;



/*
@@ -4373,6 +4391,8 @@ TEST_P(AttestationTest, HmacAttestation) { 
                        &cert_chain));

}



INSTANTIATE_KEYMASTER_HIDL_TEST(AttestationTest);



typedef KeymasterHidlTest KeyDeletionTest;



/**
@@ -4478,6 +4498,8 @@ TEST_P(KeyDeletionTest, DeleteAllKeys) { 
    }

}



INSTANTIATE_KEYMASTER_HIDL_TEST(KeyDeletionTest);



using UpgradeKeyTest = KeymasterHidlTest;



/*
@@ -4497,6 +4519,8 @@ TEST_P(UpgradeKeyTest, UpgradeKey) { 
    EXPECT_EQ(result, std::make_pair(ErrorCode::OK, HidlBuf()));

}



INSTANTIATE_KEYMASTER_HIDL_TEST(UpgradeKeyTest);



using ClearOperationsTest = KeymasterHidlTest;



/*
@@ -4572,6 +4596,8 @@ TEST_P(ClearOperationsTest, ServiceDeath) { 
    }

}



INSTANTIATE_KEYMASTER_HIDL_TEST(ClearOperationsTest);



typedef KeymasterHidlTest TransportLimitTest;



/*
@@ -4624,44 +4650,7 @@ TEST_P(TransportLimitTest, LargeFinishInput) { 
    CheckedDeleteKey();

}



static const auto kKeymasterDeviceChoices =

        testing::ValuesIn(android::hardware::getAllHalInstanceNames(IKeymasterDevice::descriptor));



INSTANTIATE_TEST_SUITE_P(PerInstance, NewKeyGenerationTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, ImportKeyTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, ImportWrappedKeyTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, SigningOperationsTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, VerificationOperationsTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, ExportKeyTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, EncryptionOperationsTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, MaxOperationsTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, AddEntropyTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, AttestationTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, KeyDeletionTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);



INSTANTIATE_TEST_SUITE_P(PerInstance, TransportLimitTest, kKeymasterDeviceChoices,

                         android::hardware::PrintInstanceNameToString);

INSTANTIATE_KEYMASTER_HIDL_TEST(TransportLimitTest);



}  // namespace test

}  // namespace V4_0