diff --git a/keymaster/4.0/support/include/keymasterV4_0/keymaster_utils.h b/keymaster/4.0/support/include/keymasterV4_0/keymaster_utils.h index 5e5ae8d0ed..61645f853e 100644 --- a/keymaster/4.0/support/include/keymasterV4_0/keymaster_utils.h +++ b/keymaster/4.0/support/include/keymasterV4_0/keymaster_utils.h @@ -52,6 +52,9 @@ inline static hidl_vec blob2hidlVec(const std::vector& blob) { HardwareAuthToken hidlVec2AuthToken(const hidl_vec& buffer); hidl_vec authToken2HidlVec(const HardwareAuthToken& token); +uint32_t getOsVersion(); +uint32_t getOsPatchlevel(); + } // namespace support } // namespace V4_0 } // namespace keymaster diff --git a/keymaster/4.0/support/keymaster_utils.cpp b/keymaster/4.0/support/keymaster_utils.cpp index e35fdd36d5..850a7767bf 100644 --- a/keymaster/4.0/support/keymaster_utils.cpp +++ b/keymaster/4.0/support/keymaster_utils.cpp @@ -14,11 +14,13 @@ * limitations under the License. */ +#include + +#include #include #include -namespace android { -namespace hardware { +namespace android::hardware { inline static bool operator<(const hidl_vec& a, const hidl_vec& b) { auto result = memcmp(a.data(), b.data(), std::min(a.size(), b.size())); @@ -32,8 +34,7 @@ inline static bool operator<(const hidl_array& a, return memcmp(a.data(), b.data(), SIZE) == -1; } -namespace keymaster { -namespace V4_0 { +namespace keymaster::V4_0 { bool operator<(const HmacSharingParameters& a, const HmacSharingParameters& b) { return std::tie(a.seed, a.nonce) < std::tie(b.seed, b.nonce); @@ -58,9 +59,9 @@ constexpr size_t kHmacSize = 32; hidl_vec authToken2HidlVec(const HardwareAuthToken& token) { static_assert(1 /* version size */ + sizeof(token.challenge) + sizeof(token.userId) + - sizeof(token.authenticatorId) + sizeof(token.authenticatorType) + - sizeof(token.timestamp) + kHmacSize == - sizeof(hw_auth_token_t), + sizeof(token.authenticatorId) + sizeof(token.authenticatorType) + + sizeof(token.timestamp) + kHmacSize == + sizeof(hw_auth_token_t), "HardwareAuthToken content size does not match hw_auth_token_t size"); hidl_vec result; @@ -86,9 +87,9 @@ hidl_vec authToken2HidlVec(const HardwareAuthToken& token) { HardwareAuthToken hidlVec2AuthToken(const hidl_vec& buffer) { HardwareAuthToken token; static_assert(1 /* version size */ + sizeof(token.challenge) + sizeof(token.userId) + - sizeof(token.authenticatorId) + sizeof(token.authenticatorType) + - sizeof(token.timestamp) + kHmacSize == - sizeof(hw_auth_token_t), + sizeof(token.authenticatorId) + sizeof(token.authenticatorType) + + sizeof(token.timestamp) + kHmacSize == + sizeof(hw_auth_token_t), "HardwareAuthToken content size does not match hw_auth_token_t size"); if (buffer.size() != sizeof(hw_auth_token_t)) return {}; @@ -100,7 +101,7 @@ HardwareAuthToken hidlVec2AuthToken(const hidl_vec& buffer) { pos = copy_bytes_from_iterator(&token.authenticatorId, pos); pos = copy_bytes_from_iterator(&token.authenticatorType, pos); token.authenticatorType = static_cast( - ntohl(static_cast(token.authenticatorType))); + ntohl(static_cast(token.authenticatorType))); pos = copy_bytes_from_iterator(&token.timestamp, pos); token.timestamp = ntohq(token.timestamp); token.mac.resize(kHmacSize); @@ -109,8 +110,93 @@ HardwareAuthToken hidlVec2AuthToken(const hidl_vec& buffer) { return token; } +namespace { + +constexpr char kPlatformVersionProp[] = "ro.build.version.release"; +constexpr char kPlatformVersionRegex[] = "^([0-9]{1,2})(\\.([0-9]{1,2}))?(\\.([0-9]{1,2}))?"; +constexpr size_t kMajorVersionMatch = 1; +constexpr size_t kMinorVersionMatch = 3; +constexpr size_t kSubminorVersionMatch = 5; +constexpr size_t kPlatformVersionMatchCount = kSubminorVersionMatch + 1; + +constexpr char kPlatformPatchlevelProp[] = "ro.build.version.security_patch"; +constexpr char kPlatformPatchlevelRegex[] = "^([0-9]{4})-([0-9]{2})-[0-9]{2}$"; +constexpr size_t kYearMatch = 1; +constexpr size_t kMonthMatch = 2; +constexpr size_t kPlatformPatchlevelMatchCount = kMonthMatch + 1; + +uint32_t match_to_uint32(const char* expression, const regmatch_t& match) { + if (match.rm_so == -1) return 0; + + size_t len = match.rm_eo - match.rm_so; + std::string s(expression + match.rm_so, len); + return std::stoul(s); +} + +std::string wait_and_get_property(const char* prop) { + std::string prop_value; + while (!android::base::WaitForPropertyCreation(prop)) + ; + prop_value = android::base::GetProperty(prop, "" /* default */); + return prop_value; +} + +} // anonymous namespace + +uint32_t getOsVersion(const char* version_str) { + regex_t regex; + if (regcomp(®ex, kPlatformVersionRegex, REG_EXTENDED)) { + return 0; + } + + regmatch_t matches[kPlatformVersionMatchCount]; + int not_match = + regexec(®ex, version_str, kPlatformVersionMatchCount, matches, 0 /* flags */); + regfree(®ex); + if (not_match) { + return 0; + } + + uint32_t major = match_to_uint32(version_str, matches[kMajorVersionMatch]); + uint32_t minor = match_to_uint32(version_str, matches[kMinorVersionMatch]); + uint32_t subminor = match_to_uint32(version_str, matches[kSubminorVersionMatch]); + + return (major * 100 + minor) * 100 + subminor; +} + +uint32_t getOsVersion() { + std::string version = wait_and_get_property(kPlatformVersionProp); + return getOsVersion(version.c_str()); +} + +uint32_t getOsPatchlevel(const char* patchlevel_str) { + regex_t regex; + if (regcomp(®ex, kPlatformPatchlevelRegex, REG_EXTENDED) != 0) { + return 0; + } + + regmatch_t matches[kPlatformPatchlevelMatchCount]; + int not_match = + regexec(®ex, patchlevel_str, kPlatformPatchlevelMatchCount, matches, 0 /* flags */); + regfree(®ex); + if (not_match) { + return 0; + } + + uint32_t year = match_to_uint32(patchlevel_str, matches[kYearMatch]); + uint32_t month = match_to_uint32(patchlevel_str, matches[kMonthMatch]); + + if (month < 1 || month > 12) { + return 0; + } + return year * 100 + month; +} + +uint32_t getOsPatchlevel() { + std::string patchlevel = wait_and_get_property(kPlatformPatchlevelProp); + return getOsPatchlevel(patchlevel.c_str()); +} + } // namespace support -} // namespace V4_0 -} // namespace keymaster -} // namespace hardware -} // namespace android +} // namespace keymaster::V4_0 +} // namespace android::hardware diff --git a/keymaster/4.0/vts/functional/Android.bp b/keymaster/4.0/vts/functional/Android.bp index 5649f20f86..7244ae3c96 100644 --- a/keymaster/4.0/vts/functional/Android.bp +++ b/keymaster/4.0/vts/functional/Android.bp @@ -27,7 +27,9 @@ cc_test { "android.hardware.keymaster@4.0", "libcrypto_static", "libkeymaster4support", - "libsoftkeymasterdevice", ], - test_suites: ["general-tests", "vts-core"], + test_suites: [ + "general-tests", + "vts-core", + ], } diff --git a/keymaster/4.0/vts/functional/HmacKeySharingTest.cpp b/keymaster/4.0/vts/functional/HmacKeySharingTest.cpp index c228ef709d..f57a6682f9 100644 --- a/keymaster/4.0/vts/functional/HmacKeySharingTest.cpp +++ b/keymaster/4.0/vts/functional/HmacKeySharingTest.cpp @@ -28,6 +28,16 @@ namespace test { */ class HmacKeySharingTest : public KeymasterHidlTest { protected: + const std::vector>& 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> all_keymasters_; }; +std::vector> 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()) - << "One or more keymasters failed to provide parameters."; + 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()) - << "One or more keymasters failed to provide parameters."; + 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()) - << "One or more keymasters failed to provide parameters."; + 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()) - << "One or more keymasters failed to provide parameters."; + 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 diff --git a/keymaster/4.0/vts/functional/KeymasterHidlTest.cpp b/keymaster/4.0/vts/functional/KeymasterHidlTest.cpp index 7241984694..5d0e262ca5 100644 --- a/keymaster/4.0/vts/functional/KeymasterHidlTest.cpp +++ b/keymaster/4.0/vts/functional/KeymasterHidlTest.cpp @@ -23,6 +23,7 @@ #include #include +#include namespace android { namespace hardware { @@ -41,39 +42,27 @@ 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_ - ->getHardwareInfo([&](SecurityLevel securityLevel, const hidl_string& name, - const hidl_string& author) { - securityLevel_ = securityLevel; - name_ = name; - author_ = author; - }) - .isOk()); + ->getHardwareInfo([&](SecurityLevel securityLevel, const hidl_string& name, + const hidl_string& author) { + securityLevel_ = securityLevel; + name_ = name; + author_ = author; + }) + .isOk()); } void KeymasterHidlTest::SetUp() { InitializeKeymaster(); - os_version_ = ::keymaster::GetOsVersion(); - os_patch_level_ = ::keymaster::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& names) { - for (auto& name : names) { - if (name == service_name_) continue; - auto keymaster = IKeymasterDevice::getService(name); - ASSERT_NE(keymaster, nullptr); - all_keymasters_.push_back(keymaster); - } - }); + os_version_ = support::getOsVersion(); + os_patch_level_ = support::getOsPatchlevel(); } ErrorCode KeymasterHidlTest::GenerateKey(const AuthorizationSet& key_desc, HidlBuf* key_blob, diff --git a/keymaster/4.0/vts/functional/KeymasterHidlTest.h b/keymaster/4.0/vts/functional/KeymasterHidlTest.h index 4bd8b26db9..faa7c75409 100644 --- a/keymaster/4.0/vts/functional/KeymasterHidlTest.h +++ b/keymaster/4.0/vts/functional/KeymasterHidlTest.h @@ -21,7 +21,6 @@ #include #include #include -#include #include @@ -35,13 +34,13 @@ 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 { typedef hidl_vec super; - public: + public: HidlBuf() {} HidlBuf(const super& other) : super(other) {} HidlBuf(super&& other) : super(std::move(other)) {} @@ -70,20 +69,16 @@ constexpr uint64_t kOpHandleSentinel = 0xFFFFFFFFFFFFFFFF; class KeymasterHidlTest : public ::testing::TestWithParam { 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>& all_keymasters() { return all_keymasters_; } uint32_t os_version() { return os_version_; } uint32_t os_patch_level() { return os_patch_level_; } @@ -209,18 +204,22 @@ class KeymasterHidlTest : public ::testing::TestWithParam { KeyCharacteristics key_characteristics_; OperationHandle op_handle_ = kOpHandleSentinel; - private: - sp keymaster_; - std::vector> all_keymasters_; - uint32_t os_version_; - uint32_t os_patch_level_; + private: + sp keymaster_; + uint32_t os_version_; + uint32_t os_patch_level_; - SecurityLevel securityLevel_; - hidl_string name_; - hidl_string author_; - string service_name_; + SecurityLevel securityLevel_; + hidl_string name_; + hidl_string author_; }; +#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 diff --git a/keymaster/4.0/vts/functional/VerificationTokenTest.cpp b/keymaster/4.0/vts/functional/VerificationTokenTest.cpp index 693f4ae0e4..bab1439584 100644 --- a/keymaster/4.0/vts/functional/VerificationTokenTest.cpp +++ b/keymaster/4.0/vts/functional/VerificationTokenTest.cpp @@ -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 diff --git a/keymaster/4.0/vts/functional/keymaster_hidl_hal_test.cpp b/keymaster/4.0/vts/functional/keymaster_hidl_hal_test.cpp index 66132adc94..d9131f59c7 100644 --- a/keymaster/4.0/vts/functional/keymaster_hidl_hal_test.cpp +++ b/keymaster/4.0/vts/functional/keymaster_hidl_hal_test.cpp @@ -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 @@ -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 diff --git a/keymaster/4.1/vts/functional/EarlyBootKeyTest.cpp b/keymaster/4.1/vts/functional/EarlyBootKeyTest.cpp index 4a19010c46..d1978a9cdf 100644 --- a/keymaster/4.1/vts/functional/EarlyBootKeyTest.cpp +++ b/keymaster/4.1/vts/functional/EarlyBootKeyTest.cpp @@ -16,6 +16,6 @@ namespace android::hardware::keymaster::V4_1::test { -// TODO(swillden): Put tests here. + } // namespace android::hardware::keymaster::V4_1::test