| /* |
| * Copyright (C) 2022 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. |
| */ |
| |
| #define LOG_TAG "ConfirmationIOAidlHalTest" |
| |
| #include <algorithm> |
| #include <condition_variable> |
| #include <future> |
| #include <iostream> |
| #include <memory> |
| #include <mutex> |
| |
| #include <aidl/Gtest.h> |
| #include <aidl/Vintf.h> |
| #include <aidl/android/hardware/confirmationui/BnConfirmationResultCallback.h> |
| #include <aidl/android/hardware/confirmationui/IConfirmationUI.h> |
| #include <aidl/android/hardware/confirmationui/TestModeCommands.h> |
| #include <aidl/android/hardware/confirmationui/UIOption.h> |
| #include <android-base/thread_annotations.h> |
| #include <android/hardware/confirmationui/support/confirmationui_utils.h> |
| #include <cutils/log.h> |
| |
| #include <openssl/hmac.h> |
| #include <openssl/sha.h> |
| |
| #include <cn-cbor/cn-cbor.h> |
| |
| #include <android/binder_manager.h> |
| #include <android/binder_process.h> |
| #include <android/binder_status.h> |
| |
| static constexpr int TIMEOUT_PERIOD = 10; |
| |
| namespace aidl::android::hardware::confirmationui::test { |
| using ::aidl::android::hardware::security::keymint::HardwareAuthenticatorType; |
| using ::aidl::android::hardware::security::keymint::HardwareAuthToken; |
| using ::android::hardware::confirmationui::support::auth_token_key_t; |
| using ::android::hardware::confirmationui::support::ByteBufferProxy; |
| using ::android::hardware::confirmationui::support::HMac; |
| using ::android::hardware::confirmationui::support::hmac_t; |
| using ::android::hardware::confirmationui::support::hton; |
| using ::android::hardware::confirmationui::support::NullOr; |
| using std::shared_ptr; |
| using std::string; |
| using std::vector; |
| |
| namespace { |
| const auth_token_key_t testKey(static_cast<uint8_t>(IConfirmationUI::TEST_KEY_BYTE)); |
| |
| class HMacImplementation { |
| public: |
| static NullOr<hmac_t> hmac256(const auth_token_key_t& key, |
| std::initializer_list<ByteBufferProxy> buffers) { |
| HMAC_CTX hmacCtx; |
| HMAC_CTX_init(&hmacCtx); |
| if (!HMAC_Init_ex(&hmacCtx, key.data(), key.size(), EVP_sha256(), nullptr)) { |
| return {}; |
| } |
| for (auto& buffer : buffers) { |
| if (!HMAC_Update(&hmacCtx, buffer.data(), buffer.size())) { |
| return {}; |
| } |
| } |
| hmac_t result; |
| if (!HMAC_Final(&hmacCtx, result.data(), nullptr)) { |
| return {}; |
| } |
| return result; |
| } |
| }; |
| |
| using HMacer = HMac<HMacImplementation>; |
| |
| template <typename... Data> |
| vector<uint8_t> testHMAC(const Data&... data) { |
| auto hmac = HMacer::hmac256(testKey, data...); |
| if (!hmac.isOk()) { |
| ADD_FAILURE() << "Failed to compute test hmac. This is a self-test error."; |
| return {}; |
| } |
| vector<uint8_t> result(hmac.value().size()); |
| std::copy(hmac.value().data(), hmac.value().data() + hmac.value().size(), result.data()); |
| return result; |
| } |
| |
| template <typename T> |
| auto toBytes(const T& v) -> const uint8_t (&)[sizeof(T)] { |
| return *reinterpret_cast<const uint8_t(*)[sizeof(T)]>(&v); |
| } |
| |
| HardwareAuthToken makeTestToken(const TestModeCommands command, uint64_t timestamp = 0) { |
| HardwareAuthToken auth_token; |
| auth_token.challenge = static_cast<uint64_t>(command); |
| auth_token.userId = 0; |
| auth_token.authenticatorId = 0; |
| auth_token.authenticatorType = HardwareAuthenticatorType::NONE; |
| auth_token.timestamp = {static_cast<int64_t>(timestamp)}; |
| |
| // Canonical form of auth-token v0 |
| // version (1 byte) |
| // challenge (8 bytes) |
| // user_id (8 bytes) |
| // authenticator_id (8 bytes) |
| // authenticator_type (4 bytes) |
| // timestamp (8 bytes) |
| // total 37 bytes |
| auth_token.mac = testHMAC("\0", |
| toBytes(auth_token.challenge), // |
| toBytes(auth_token.userId), // |
| toBytes(auth_token.authenticatorId), // |
| toBytes(hton(auth_token.authenticatorType)), // |
| toBytes(hton(auth_token.timestamp))); // |
| |
| return auth_token; |
| } |
| |
| #define DEBUG_CONFRIMATIONUI_UTILS_TEST |
| |
| #ifdef DEBUG_CONFRIMATIONUI_UTILS_TEST |
| std::ostream& hexdump(std::ostream& out, const uint8_t* data, size_t size) { |
| for (size_t i = 0; i < size; ++i) { |
| uint8_t byte = data[i]; |
| out << std::hex << std::setw(2) << std::setfill('0') << (unsigned)byte; |
| switch (i & 0xf) { |
| case 0xf: |
| out << "\n"; |
| break; |
| case 7: |
| out << " "; |
| break; |
| default: |
| out << " "; |
| break; |
| } |
| } |
| return out; |
| } |
| #endif |
| |
| constexpr char hex_value[256] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, // '0'..'9' |
| 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 'A'..'F' |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 'a'..'f' |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| |
| std::string hex2str(std::string a) { |
| std::string b; |
| size_t num = a.size() / 2; |
| b.resize(num); |
| for (size_t i = 0; i < num; i++) { |
| b[i] = (hex_value[a[i * 2] & 0xFF] << 4) + (hex_value[a[i * 2 + 1] & 0xFF]); |
| } |
| return b; |
| } |
| |
| int getReturnCode(const ::ndk::ScopedAStatus& result) { |
| if (result.isOk()) return IConfirmationUI::OK; |
| |
| if (result.getExceptionCode() == EX_SERVICE_SPECIFIC) { |
| return static_cast<int>(result.getServiceSpecificError()); |
| } |
| return result.getStatus(); |
| } |
| |
| } // namespace |
| |
| class ConfirmationUIAidlTest : public ::testing::TestWithParam<std::string> { |
| public: |
| void TearDown() override { confirmator_->abort(); } |
| void SetUp() override { |
| // Wake up the device in-case screen is off. b/332827323 |
| int ret = system("input keyevent KEYCODE_WAKEUP"); |
| if (ret != 0) { |
| ALOGE("Failed to run keyevent KEYCODE_WAKEUP command"); |
| } |
| usleep(100000); // wait for 100ms to wake up the screen. |
| std::string name = GetParam(); |
| ASSERT_TRUE(AServiceManager_isDeclared(name.c_str())) << name; |
| ndk::SpAIBinder binder(AServiceManager_waitForService(name.c_str())); |
| ASSERT_NE(binder, nullptr); |
| confirmator_ = IConfirmationUI::fromBinder(binder); |
| ASSERT_NE(confirmator_, nullptr); |
| } |
| |
| // Used as a mechanism to inform the test about data/event callback |
| inline void notify() { |
| std::unique_lock<std::mutex> lock(mtx_); |
| cv_.notify_one(); |
| } |
| |
| // Test code calls this function to wait for data/event callback |
| inline std::cv_status wait() { |
| std::unique_lock<std::mutex> lock(mtx_); |
| auto now = std::chrono::system_clock::now(); |
| std::cv_status status = cv_.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD)); |
| return status; |
| } |
| |
| protected: |
| shared_ptr<IConfirmationUI> confirmator_; |
| |
| private: |
| // synchronization objects |
| std::mutex mtx_; |
| std::condition_variable cv_; |
| }; |
| |
| class ConfirmationTestCallback |
| : public ::aidl::android::hardware::confirmationui::BnConfirmationResultCallback { |
| public: |
| ConfirmationTestCallback(ConfirmationUIAidlTest& parent) : parent_(parent){}; |
| virtual ~ConfirmationTestCallback() = default; |
| |
| ::ndk::ScopedAStatus result(int32_t err, const vector<uint8_t>& msg, |
| const vector<uint8_t>& confToken) override { |
| error_ = err; |
| formattedMessage_ = msg; |
| confirmationToken_ = confToken; |
| parent_.notify(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| bool verifyConfirmationToken() { |
| static constexpr char confirmationPrefix[] = "confirmation token"; |
| EXPECT_EQ(32U, confirmationToken_.size()); |
| return 32U == confirmationToken_.size() && |
| !memcmp(confirmationToken_.data(), |
| testHMAC(confirmationPrefix, formattedMessage_).data(), 32); |
| } |
| |
| int error_; |
| vector<uint8_t> formattedMessage_; |
| vector<uint8_t> confirmationToken_; |
| |
| private: |
| ConfirmationUIAidlTest& parent_; |
| }; |
| |
| struct CnCborDeleter { |
| void operator()(cn_cbor* ptr) { cn_cbor_free(ptr); } |
| }; |
| |
| typedef std::unique_ptr<cn_cbor, CnCborDeleter> CnCborPtr; |
| |
| // Simulates the User taping Ok |
| TEST_P(ConfirmationUIAidlTest, UserOkTest) { |
| static constexpr char test_prompt[] = "Me first, gimme gimme!"; |
| static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3}; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + 3); |
| ASSERT_TRUE(confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}).isOk()); |
| // Simulate the user taping ok. |
| ASSERT_TRUE(confirmator_->deliverSecureInputEvent(makeTestToken(TestModeCommands::OK_EVENT)) |
| .isOk()); |
| // Wait for the callback. |
| EXPECT_EQ(std::cv_status::no_timeout, wait()); |
| ASSERT_EQ(IConfirmationUI::OK, conf_cb->error_); |
| |
| ASSERT_TRUE(conf_cb->verifyConfirmationToken()); |
| |
| cn_cbor_errback cn_cbor_error; |
| auto parsed_message = CnCborPtr(cn_cbor_decode( |
| conf_cb->formattedMessage_.data(), conf_cb->formattedMessage_.size(), &cn_cbor_error)); |
| // is parsable CBOR |
| ASSERT_TRUE(parsed_message.get()); |
| // is a map |
| ASSERT_EQ(CN_CBOR_MAP, parsed_message->type); |
| |
| // the message must have exactly 2 key value pairs. |
| // cn_cbor holds 2*<no_of_pairs> in the length field |
| ASSERT_EQ(4, parsed_message->length); |
| // map has key "prompt" |
| auto prompt = cn_cbor_mapget_string(parsed_message.get(), "prompt"); |
| ASSERT_TRUE(prompt); |
| ASSERT_EQ(CN_CBOR_TEXT, prompt->type); |
| ASSERT_EQ(22, prompt->length); |
| ASSERT_EQ(0, memcmp(test_prompt, prompt->v.str, 22)); |
| // map has key "extra" |
| auto extra_out = cn_cbor_mapget_string(parsed_message.get(), "extra"); |
| ASSERT_TRUE(extra_out); |
| ASSERT_EQ(CN_CBOR_BYTES, extra_out->type); |
| ASSERT_EQ(3, extra_out->length); |
| ASSERT_EQ(0, memcmp(test_extra, extra_out->v.bytes, 3)); |
| } |
| |
| // Initiates a confirmation prompt with a message that is too long |
| TEST_P(ConfirmationUIAidlTest, MessageTooLongTest) { |
| static constexpr uint8_t test_extra[IConfirmationUI::MAX_MESSAGE_SIZE] = {}; |
| static constexpr char test_prompt[] = "D\'oh!"; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + sizeof(test_extra)); |
| auto result = confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}); |
| ASSERT_EQ(IConfirmationUI::UI_ERROR_MESSAGE_TOO_LONG, getReturnCode(result)); |
| } |
| |
| // If the message gets very long some HAL implementations might fail even before the message |
| // reaches the trusted app implementation. But the HAL must still diagnose the correct error. |
| TEST_P(ConfirmationUIAidlTest, MessageWayTooLongTest) { |
| static constexpr uint8_t test_extra[(IConfirmationUI::MAX_MESSAGE_SIZE)*10] = {}; |
| static constexpr char test_prompt[] = "D\'oh!"; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + sizeof(test_extra)); |
| auto result = confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}); |
| ASSERT_EQ(IConfirmationUI::UI_ERROR_MESSAGE_TOO_LONG, getReturnCode(result)); |
| } |
| |
| // Simulates the User tapping the Cancel |
| TEST_P(ConfirmationUIAidlTest, UserCancelTest) { |
| static constexpr char test_prompt[] = "Me first, gimme gimme!"; |
| static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3}; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + 3); |
| ASSERT_TRUE(confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}).isOk()); |
| |
| // Simulate the user taping ok. |
| ASSERT_TRUE(confirmator_->deliverSecureInputEvent(makeTestToken(TestModeCommands::CANCEL_EVENT)) |
| .isOk()); |
| // Wait for the callback. |
| EXPECT_EQ(std::cv_status::no_timeout, wait()); |
| ASSERT_EQ(IConfirmationUI::CANCELED, conf_cb->error_); |
| |
| ASSERT_EQ(0U, conf_cb->confirmationToken_.size()); |
| ASSERT_EQ(0U, conf_cb->formattedMessage_.size()); |
| } |
| |
| // Simulates the framework cancelling an ongoing prompt |
| TEST_P(ConfirmationUIAidlTest, AbortTest) { |
| static constexpr char test_prompt[] = "Me first, gimme gimme!"; |
| static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3}; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + 3); |
| ASSERT_TRUE(confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}).isOk()); |
| |
| confirmator_->abort(); |
| |
| // Wait for the callback. |
| EXPECT_EQ(std::cv_status::no_timeout, wait()); |
| ASSERT_EQ(IConfirmationUI::ABORTED, conf_cb->error_); |
| ASSERT_EQ(0U, conf_cb->confirmationToken_.size()); |
| ASSERT_EQ(0U, conf_cb->formattedMessage_.size()); |
| } |
| |
| // Tests if the confirmation dialog can successfully render 100 'W' characters as required by |
| // the design guidelines. |
| TEST_P(ConfirmationUIAidlTest, PortableMessageTest1) { |
| static constexpr char test_prompt[] = |
| "WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW" |
| "WWWWWWWWWWWWWW"; |
| static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3}; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + 3); |
| ASSERT_TRUE(confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}).isOk()); |
| |
| confirmator_->abort(); |
| |
| // Wait for the callback. |
| EXPECT_EQ(std::cv_status::no_timeout, wait()); |
| ASSERT_EQ(IConfirmationUI::ABORTED, conf_cb->error_); |
| ASSERT_EQ(0U, conf_cb->confirmationToken_.size()); |
| ASSERT_EQ(0U, conf_cb->formattedMessage_.size()); |
| } |
| |
| // Tests if the confirmation dialog can successfully render 100 'W' characters as required by |
| // the design guidelines in magnified mode. |
| TEST_P(ConfirmationUIAidlTest, PortableMessageTest1Magnified) { |
| static constexpr char test_prompt[] = |
| "WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW" |
| "WWWWWWWWWWWWWW"; |
| static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3}; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + 3); |
| ASSERT_TRUE(confirmator_ |
| ->promptUserConfirmation(conf_cb, prompt_text, extra, "en", |
| {UIOption::ACCESSIBILITY_MAGNIFIED}) |
| .isOk()); |
| |
| confirmator_->abort(); |
| |
| // Wait for the callback. |
| EXPECT_EQ(std::cv_status::no_timeout, wait()); |
| ASSERT_EQ(IConfirmationUI::ABORTED, conf_cb->error_); |
| ASSERT_EQ(0U, conf_cb->confirmationToken_.size()); |
| ASSERT_EQ(0U, conf_cb->formattedMessage_.size()); |
| } |
| |
| // Tests if the confirmation dialog can successfully render 8 groups of 12 'W' characters as |
| // required by the design guidelines. |
| TEST_P(ConfirmationUIAidlTest, PortableMessageTest2) { |
| static constexpr char test_prompt[] = |
| "WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW " |
| "WWWWWWWWWWWW WWWWWWWWWWWW"; |
| static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3}; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + 3); |
| ASSERT_TRUE(confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}).isOk()); |
| |
| confirmator_->abort(); |
| |
| // Wait for the callback. |
| EXPECT_EQ(std::cv_status::no_timeout, wait()); |
| ASSERT_EQ(IConfirmationUI::ABORTED, conf_cb->error_); |
| ASSERT_EQ(0U, conf_cb->confirmationToken_.size()); |
| ASSERT_EQ(0U, conf_cb->formattedMessage_.size()); |
| } |
| |
| // Tests if the confirmation dialog can successfully render 8 groups of 12 'W' characters as |
| // required by the design guidelines in magnified mode. |
| TEST_P(ConfirmationUIAidlTest, PortableMessageTest2Magnified) { |
| static constexpr char test_prompt[] = |
| "WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW " |
| "WWWWWWWWWWWW WWWWWWWWWWWW"; |
| static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3}; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + 3); |
| ASSERT_TRUE(confirmator_ |
| ->promptUserConfirmation(conf_cb, prompt_text, extra, "en", |
| {UIOption::ACCESSIBILITY_MAGNIFIED}) |
| .isOk()); |
| |
| confirmator_->abort(); |
| |
| // Wait for the callback. |
| EXPECT_EQ(std::cv_status::no_timeout, wait()); |
| ASSERT_EQ(IConfirmationUI::ABORTED, conf_cb->error_); |
| ASSERT_EQ(0U, conf_cb->confirmationToken_.size()); |
| ASSERT_EQ(0U, conf_cb->formattedMessage_.size()); |
| } |
| |
| // Passing malformed UTF-8 to the confirmation UI |
| // This test passes a string that ends in the middle of a multibyte character |
| TEST_P(ConfirmationUIAidlTest, MalformedUTF8Test1) { |
| static constexpr char test_prompt[] = {char(0xc0), 0}; |
| static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3}; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + 3); |
| auto result = confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}); |
| ASSERT_EQ(IConfirmationUI::UI_ERROR_MALFORMED_UTF8ENCODING, getReturnCode(result)); |
| } |
| |
| // Passing malformed UTF-8 to the confirmation UI |
| // This test passes a string with a 5-byte character. |
| TEST_P(ConfirmationUIAidlTest, MalformedUTF8Test2) { |
| static constexpr char test_prompt[] = {char(0xf8), char(0x82), char(0x82), |
| char(0x82), char(0x82), 0}; |
| static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3}; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + 3); |
| auto result = confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}); |
| ASSERT_EQ(IConfirmationUI::UI_ERROR_MALFORMED_UTF8ENCODING, getReturnCode(result)); |
| } |
| |
| // Passing malformed UTF-8 to the confirmation UI |
| // This test passes a string with a 2-byte character followed by a stray non UTF-8 character. |
| TEST_P(ConfirmationUIAidlTest, MalformedUTF8Test3) { |
| static constexpr char test_prompt[] = {char(0xc0), char(0x82), char(0x83), 0}; |
| static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3}; |
| shared_ptr<ConfirmationTestCallback> conf_cb = |
| ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this); |
| vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt)); |
| vector<uint8_t> extra(test_extra, test_extra + 3); |
| auto result = confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}); |
| ASSERT_EQ(IConfirmationUI::UI_ERROR_MALFORMED_UTF8ENCODING, getReturnCode(result)); |
| } |
| |
| // Test the implementation of HMAC SHA 256 against a golden blob. |
| TEST(ConfirmationUITestSelfTest, HMAC256SelfTest) { |
| const char key_str[32] = "keykeykeykeykeykeykeykeykeykeyk"; |
| const uint8_t(&key)[32] = *reinterpret_cast<const uint8_t(*)[32]>(key_str); |
| auto expected = hex2str("2377fbcaa7fb3f6c20cfa1d9ebc60e9922cf58c909e25e300f3cb57f7805c886"); |
| auto result = HMacer::hmac256(key, "value1", "value2", "value3"); |
| |
| #ifdef DEBUG_CONFRIMATIONUI_UTILS_TEST |
| hexdump(std::cout, reinterpret_cast<const uint8_t*>(expected.data()), 32) << std::endl; |
| hexdump(std::cout, result.value().data(), 32) << std::endl; |
| #endif |
| |
| ByteBufferProxy expected_bytes(expected); |
| ASSERT_TRUE(result.isOk()); |
| ASSERT_EQ(expected, result.value()); |
| } |
| |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ConfirmationUIAidlTest); |
| INSTANTIATE_TEST_SUITE_P( |
| PerInstance, ConfirmationUIAidlTest, |
| testing::ValuesIn(::android::getAidlHalInstanceNames(IConfirmationUI::descriptor)), |
| ::android::PrintInstanceNameToString); |
| |
| } // namespace aidl::android::hardware::confirmationui::test |
| |
| int main(int argc, char** argv) { |
| ::testing::InitGoogleTest(&argc, argv); |
| ABinderProcess_setThreadPoolMaxThreadCount(1); |
| ABinderProcess_startThreadPool(); |
| return RUN_ALL_TESTS(); |
| } |
