/* * Copyright (C) 2017 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. */ #ifndef HARDWARE_INTERFACES_KEYMASTER_40_VTS_FUNCTIONAL_KEYMASTER_HIDL_TEST_H_ #define HARDWARE_INTERFACES_KEYMASTER_40_VTS_FUNCTIONAL_KEYMASTER_HIDL_TEST_H_ #include <android/hardware/keymaster/4.0/IKeymasterDevice.h> #include <android/hardware/keymaster/4.0/types.h> #include <VtsHalHidlTargetTestBase.h> #include <keymaster/keymaster_configuration.h> #include <keymasterV4_0/authorization_set.h> namespace android { namespace hardware { namespace keymaster { namespace V4_0 { ::std::ostream& operator<<(::std::ostream& os, const AuthorizationSet& set); namespace test { using ::android::sp; using ::std::string; class HidlBuf : public hidl_vec<uint8_t> { typedef hidl_vec<uint8_t> super; public: HidlBuf() {} HidlBuf(const super& other) : super(other) {} HidlBuf(super&& other) : super(std::move(other)) {} explicit HidlBuf(const std::string& other) : HidlBuf() { *this = other; } HidlBuf& operator=(const super& other) { super::operator=(other); return *this; } HidlBuf& operator=(super&& other) { super::operator=(std::move(other)); return *this; } HidlBuf& operator=(const string& other) { resize(other.size()); std::copy(other.begin(), other.end(), begin()); return *this; } string to_string() const { return string(reinterpret_cast<const char*>(data()), size()); } }; constexpr uint64_t kOpHandleSentinel = 0xFFFFFFFFFFFFFFFF; class KeymasterHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase { public: // get the test environment singleton static KeymasterHidlEnvironment* Instance() { static KeymasterHidlEnvironment* instance = new KeymasterHidlEnvironment; return instance; } void registerTestServices() override { registerTestService<IKeymasterDevice>(); } private: KeymasterHidlEnvironment(){}; GTEST_DISALLOW_COPY_AND_ASSIGN_(KeymasterHidlEnvironment); }; class KeymasterHidlTest : public ::testing::VtsHalHidlTargetTestBase { public: void TearDown() override { if (key_blob_.size()) { CheckedDeleteKey(); } AbortIfNeeded(); } // SetUpTestCase runs only once per test case, not once per test. static void SetUpTestCase(); static void TearDownTestCase() { keymaster_.clear(); all_keymasters_.clear(); } static IKeymasterDevice& keymaster() { return *keymaster_; } static const std::vector<sp<IKeymasterDevice>>& all_keymasters() { return all_keymasters_; } static uint32_t os_version() { return os_version_; } static uint32_t os_patch_level() { return os_patch_level_; } ErrorCode GenerateKey(const AuthorizationSet& key_desc, HidlBuf* key_blob, KeyCharacteristics* key_characteristics); ErrorCode GenerateKey(const AuthorizationSet& key_desc); ErrorCode ImportKey(const AuthorizationSet& key_desc, KeyFormat format, const string& key_material, HidlBuf* key_blob, KeyCharacteristics* key_characteristics); ErrorCode ImportKey(const AuthorizationSet& key_desc, KeyFormat format, const string& key_material); ErrorCode ImportWrappedKey(string wrapped_key, string wrapping_key, const AuthorizationSet& wrapping_key_desc, string masking_key, const AuthorizationSet& unwrapping_params); ErrorCode ExportKey(KeyFormat format, const HidlBuf& key_blob, const HidlBuf& client_id, const HidlBuf& app_data, HidlBuf* key_material); ErrorCode ExportKey(KeyFormat format, HidlBuf* key_material); ErrorCode DeleteKey(HidlBuf* key_blob, bool keep_key_blob = false); ErrorCode DeleteKey(bool keep_key_blob = false); ErrorCode DeleteAllKeys(); void CheckedDeleteKey(HidlBuf* key_blob, bool keep_key_blob = false); void CheckedDeleteKey(); static void CheckCreationDateTime(const AuthorizationSet& sw_enforced, std::chrono::time_point<std::chrono::system_clock> creation); void CheckGetCharacteristics(const HidlBuf& key_blob, const HidlBuf& client_id, const HidlBuf& app_data, KeyCharacteristics* key_characteristics); ErrorCode GetCharacteristics(const HidlBuf& key_blob, const HidlBuf& client_id, const HidlBuf& app_data, KeyCharacteristics* key_characteristics); ErrorCode GetCharacteristics(const HidlBuf& key_blob, KeyCharacteristics* key_characteristics); ErrorCode Begin(KeyPurpose purpose, const HidlBuf& key_blob, const AuthorizationSet& in_params, AuthorizationSet* out_params, OperationHandle* op_handle); ErrorCode Begin(KeyPurpose purpose, const AuthorizationSet& in_params, AuthorizationSet* out_params); ErrorCode Begin(KeyPurpose purpose, const AuthorizationSet& in_params); ErrorCode Update(OperationHandle op_handle, const AuthorizationSet& in_params, const string& input, AuthorizationSet* out_params, string* output, size_t* input_consumed); ErrorCode Update(const string& input, string* out, size_t* input_consumed); ErrorCode Finish(OperationHandle op_handle, const AuthorizationSet& in_params, const string& input, const string& signature, AuthorizationSet* out_params, string* output); ErrorCode Finish(const string& message, string* output); ErrorCode Finish(const string& message, const string& signature, string* output); ErrorCode Finish(string* output) { return Finish(string(), output); } ErrorCode Abort(OperationHandle op_handle); void AbortIfNeeded(); ErrorCode AttestKey(const HidlBuf& key_blob, const AuthorizationSet& attest_params, hidl_vec<hidl_vec<uint8_t>>* cert_chain); ErrorCode AttestKey(const AuthorizationSet& attest_params, hidl_vec<hidl_vec<uint8_t>>* cert_chain); string ProcessMessage(const HidlBuf& key_blob, KeyPurpose operation, const string& message, const AuthorizationSet& in_params, AuthorizationSet* out_params); string SignMessage(const HidlBuf& key_blob, const string& message, const AuthorizationSet& params); string SignMessage(const string& message, const AuthorizationSet& params); string MacMessage(const string& message, Digest digest, size_t mac_length); void CheckHmacTestVector(const string& key, const string& message, Digest digest, const string& expected_mac); void CheckAesCtrTestVector(const string& key, const string& nonce, const string& message, const string& expected_ciphertext); void CheckTripleDesTestVector(KeyPurpose purpose, BlockMode block_mode, PaddingMode padding_mode, const string& key, const string& iv, const string& input, const string& expected_output); void VerifyMessage(const HidlBuf& key_blob, const string& message, const string& signature, const AuthorizationSet& params); void VerifyMessage(const string& message, const string& signature, const AuthorizationSet& params); string EncryptMessage(const HidlBuf& key_blob, const string& message, const AuthorizationSet& in_params, AuthorizationSet* out_params); string EncryptMessage(const string& message, const AuthorizationSet& params, AuthorizationSet* out_params); string EncryptMessage(const string& message, const AuthorizationSet& params); string EncryptMessage(const string& message, BlockMode block_mode, PaddingMode padding); string EncryptMessage(const string& message, BlockMode block_mode, PaddingMode padding, HidlBuf* iv_out); string EncryptMessage(const string& message, BlockMode block_mode, PaddingMode padding, const HidlBuf& iv_in); string DecryptMessage(const HidlBuf& key_blob, const string& ciphertext, const AuthorizationSet& params); string DecryptMessage(const string& ciphertext, const AuthorizationSet& params); string DecryptMessage(const string& ciphertext, BlockMode block_mode, PaddingMode padding_mode, const HidlBuf& iv); std::pair<ErrorCode, HidlBuf> UpgradeKey(const HidlBuf& key_blob); static bool IsSecure() { return securityLevel_ != SecurityLevel::SOFTWARE; } static SecurityLevel SecLevel() { return securityLevel_; } std::vector<uint32_t> ValidKeySizes(Algorithm algorithm); std::vector<uint32_t> InvalidKeySizes(Algorithm algorithm); std::vector<EcCurve> ValidCurves(); std::vector<EcCurve> InvalidCurves(); std::vector<Digest> ValidDigests(bool withNone, bool withMD5); std::vector<Digest> InvalidDigests(); HidlBuf key_blob_; KeyCharacteristics key_characteristics_; OperationHandle op_handle_ = kOpHandleSentinel; private: static sp<IKeymasterDevice> keymaster_; static std::vector<sp<IKeymasterDevice>> all_keymasters_; static uint32_t os_version_; static uint32_t os_patch_level_; static SecurityLevel securityLevel_; static hidl_string name_; static hidl_string author_; }; } // namespace test } // namespace V4_0 } // namespace keymaster } // namespace hardware } // namespace android #endif // HARDWARE_INTERFACES_KEYMASTER_40_VTS_FUNCTIONAL_KEYMASTER_HIDL_TEST_H_