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

Commit 252233df authored by Shawn Willden's avatar Shawn Willden
Browse files

Refactor VTS tests a bit, to enable adding tests in separate files. 

Bug: 70409878
Test: VtsHalKeymasterV4_0TargetTest
Change-Id: Idd147d20761e7123005b468841a2ddb46cc19576
parent 8f074706

keymaster/4.0/vts/functional/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ cc_test { 
    name: "VtsHalKeymasterV4_0TargetTest",

    defaults: ["VtsHalTargetTestDefaults"],

    srcs: [

        "KeymasterHidlTest.cpp",

        "keymaster_hidl_hal_test.cpp",

    ],

    static_libs: [

keymaster/4.0/vts/functional/KeymasterHidlTest.cpp

0 → 100644
+589 −0

File added.

Preview size limit exceeded, changes collapsed.

keymaster/4.0/vts/functional/KeymasterHidlTest.h

0 → 100644
+229 −0
Original line number Diff line number Diff line 
/*

 * 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 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);



    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();



    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; }



    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_

keymaster/4.0/vts/functional/keymaster_hidl_hal_test.cpp

+1 −627

File changed.

Preview size limit exceeded, changes collapsed.