1 /*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "ConfirmationIOAidlHalTest"
18
19 #include <algorithm>
20 #include <condition_variable>
21 #include <future>
22 #include <iostream>
23 #include <memory>
24 #include <mutex>
25
26 #include <aidl/Gtest.h>
27 #include <aidl/Vintf.h>
28 #include <aidl/android/hardware/confirmationui/BnConfirmationResultCallback.h>
29 #include <aidl/android/hardware/confirmationui/IConfirmationUI.h>
30 #include <aidl/android/hardware/confirmationui/TestModeCommands.h>
31 #include <aidl/android/hardware/confirmationui/UIOption.h>
32 #include <android-base/thread_annotations.h>
33 #include <android/hardware/confirmationui/support/confirmationui_utils.h>
34 #include <cutils/log.h>
35
36 #include <openssl/hmac.h>
37 #include <openssl/sha.h>
38
39 #include <cn-cbor/cn-cbor.h>
40
41 #include <android/binder_manager.h>
42 #include <android/binder_process.h>
43 #include <android/binder_status.h>
44
45 static constexpr int TIMEOUT_PERIOD = 10;
46
47 namespace aidl::android::hardware::confirmationui::test {
48 using ::aidl::android::hardware::security::keymint::HardwareAuthenticatorType;
49 using ::aidl::android::hardware::security::keymint::HardwareAuthToken;
50 using ::android::hardware::confirmationui::support::auth_token_key_t;
51 using ::android::hardware::confirmationui::support::ByteBufferProxy;
52 using ::android::hardware::confirmationui::support::HMac;
53 using ::android::hardware::confirmationui::support::hmac_t;
54 using ::android::hardware::confirmationui::support::hton;
55 using ::android::hardware::confirmationui::support::NullOr;
56 using std::shared_ptr;
57 using std::string;
58 using std::vector;
59
60 namespace {
61 const auth_token_key_t testKey(static_cast<uint8_t>(IConfirmationUI::TEST_KEY_BYTE));
62
63 class HMacImplementation {
64 public:
hmac256(const auth_token_key_t & key,std::initializer_list<ByteBufferProxy> buffers)65 static NullOr<hmac_t> hmac256(const auth_token_key_t& key,
66 std::initializer_list<ByteBufferProxy> buffers) {
67 HMAC_CTX hmacCtx;
68 HMAC_CTX_init(&hmacCtx);
69 if (!HMAC_Init_ex(&hmacCtx, key.data(), key.size(), EVP_sha256(), nullptr)) {
70 return {};
71 }
72 for (auto& buffer : buffers) {
73 if (!HMAC_Update(&hmacCtx, buffer.data(), buffer.size())) {
74 return {};
75 }
76 }
77 hmac_t result;
78 if (!HMAC_Final(&hmacCtx, result.data(), nullptr)) {
79 return {};
80 }
81 return result;
82 }
83 };
84
85 using HMacer = HMac<HMacImplementation>;
86
87 template <typename... Data>
testHMAC(const Data &...data)88 vector<uint8_t> testHMAC(const Data&... data) {
89 auto hmac = HMacer::hmac256(testKey, data...);
90 if (!hmac.isOk()) {
91 ADD_FAILURE() << "Failed to compute test hmac. This is a self-test error.";
92 return {};
93 }
94 vector<uint8_t> result(hmac.value().size());
95 std::copy(hmac.value().data(), hmac.value().data() + hmac.value().size(), result.data());
96 return result;
97 }
98
99 template <typename T>
__anon37e2dfc30202null100 auto toBytes(const T& v) -> const uint8_t (&)[sizeof(T)] {
101 return *reinterpret_cast<const uint8_t(*)[sizeof(T)]>(&v);
102 }
103
104 HardwareAuthToken makeTestToken(const TestModeCommands command, uint64_t timestamp = 0) {
105 HardwareAuthToken auth_token;
106 auth_token.challenge = static_cast<uint64_t>(command);
107 auth_token.userId = 0;
108 auth_token.authenticatorId = 0;
109 auth_token.authenticatorType = HardwareAuthenticatorType::NONE;
110 auth_token.timestamp = {static_cast<int64_t>(timestamp)};
111
112 // Canonical form of auth-token v0
113 // version (1 byte)
114 // challenge (8 bytes)
115 // user_id (8 bytes)
116 // authenticator_id (8 bytes)
117 // authenticator_type (4 bytes)
118 // timestamp (8 bytes)
119 // total 37 bytes
120 auth_token.mac = testHMAC("\0",
121 toBytes(auth_token.challenge), //
122 toBytes(auth_token.userId), //
123 toBytes(auth_token.authenticatorId), //
124 toBytes(hton(auth_token.authenticatorType)), //
125 toBytes(hton(auth_token.timestamp))); //
126
127 return auth_token;
128 }
129
130 #define DEBUG_CONFRIMATIONUI_UTILS_TEST
131
132 #ifdef DEBUG_CONFRIMATIONUI_UTILS_TEST
hexdump(std::ostream & out,const uint8_t * data,size_t size)133 std::ostream& hexdump(std::ostream& out, const uint8_t* data, size_t size) {
134 for (size_t i = 0; i < size; ++i) {
135 uint8_t byte = data[i];
136 out << std::hex << std::setw(2) << std::setfill('0') << (unsigned)byte;
137 switch (i & 0xf) {
138 case 0xf:
139 out << "\n";
140 break;
141 case 7:
142 out << " ";
143 break;
144 default:
145 out << " ";
146 break;
147 }
148 }
149 return out;
150 }
151 #endif
152
153 constexpr char hex_value[256] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
154 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
155 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
156 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, // '0'..'9'
157 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 'A'..'F'
158 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
159 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 'a'..'f'
160 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
161 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
162 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
163 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
164 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
165 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
166 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
167 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
168 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
169
hex2str(std::string a)170 std::string hex2str(std::string a) {
171 std::string b;
172 size_t num = a.size() / 2;
173 b.resize(num);
174 for (size_t i = 0; i < num; i++) {
175 b[i] = (hex_value[a[i * 2] & 0xFF] << 4) + (hex_value[a[i * 2 + 1] & 0xFF]);
176 }
177 return b;
178 }
179
getReturnCode(const::ndk::ScopedAStatus & result)180 int getReturnCode(const ::ndk::ScopedAStatus& result) {
181 if (result.isOk()) return IConfirmationUI::OK;
182
183 if (result.getExceptionCode() == EX_SERVICE_SPECIFIC) {
184 return static_cast<int>(result.getServiceSpecificError());
185 }
186 return result.getStatus();
187 }
188
189 } // namespace
190
191 class ConfirmationUIAidlTest : public ::testing::TestWithParam<std::string> {
192 public:
TearDown()193 void TearDown() override { confirmator_->abort(); }
SetUp()194 void SetUp() override {
195 // Wake up the device in-case screen is off. b/332827323
196 int ret = system("input keyevent KEYCODE_WAKEUP");
197 if (ret != 0) {
198 ALOGE("Failed to run keyevent KEYCODE_WAKEUP command");
199 }
200 usleep(100000); // wait for 100ms to wake up the screen.
201 std::string name = GetParam();
202 ASSERT_TRUE(AServiceManager_isDeclared(name.c_str())) << name;
203 ndk::SpAIBinder binder(AServiceManager_waitForService(name.c_str()));
204 ASSERT_NE(binder, nullptr);
205 confirmator_ = IConfirmationUI::fromBinder(binder);
206 ASSERT_NE(confirmator_, nullptr);
207 }
208
209 // Used as a mechanism to inform the test about data/event callback
notify()210 inline void notify() {
211 std::unique_lock<std::mutex> lock(mtx_);
212 cv_.notify_one();
213 }
214
215 // Test code calls this function to wait for data/event callback
wait()216 inline std::cv_status wait() {
217 std::unique_lock<std::mutex> lock(mtx_);
218 auto now = std::chrono::system_clock::now();
219 std::cv_status status = cv_.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
220 return status;
221 }
222
223 protected:
224 shared_ptr<IConfirmationUI> confirmator_;
225
226 private:
227 // synchronization objects
228 std::mutex mtx_;
229 std::condition_variable cv_;
230 };
231
232 class ConfirmationTestCallback
233 : public ::aidl::android::hardware::confirmationui::BnConfirmationResultCallback {
234 public:
ConfirmationTestCallback(ConfirmationUIAidlTest & parent)235 ConfirmationTestCallback(ConfirmationUIAidlTest& parent) : parent_(parent){};
236 virtual ~ConfirmationTestCallback() = default;
237
result(int32_t err,const vector<uint8_t> & msg,const vector<uint8_t> & confToken)238 ::ndk::ScopedAStatus result(int32_t err, const vector<uint8_t>& msg,
239 const vector<uint8_t>& confToken) override {
240 error_ = err;
241 formattedMessage_ = msg;
242 confirmationToken_ = confToken;
243 parent_.notify();
244 return ndk::ScopedAStatus::ok();
245 }
246
verifyConfirmationToken()247 bool verifyConfirmationToken() {
248 static constexpr char confirmationPrefix[] = "confirmation token";
249 EXPECT_EQ(32U, confirmationToken_.size());
250 return 32U == confirmationToken_.size() &&
251 !memcmp(confirmationToken_.data(),
252 testHMAC(confirmationPrefix, formattedMessage_).data(), 32);
253 }
254
255 int error_;
256 vector<uint8_t> formattedMessage_;
257 vector<uint8_t> confirmationToken_;
258
259 private:
260 ConfirmationUIAidlTest& parent_;
261 };
262
263 struct CnCborDeleter {
operator ()aidl::android::hardware::confirmationui::test::CnCborDeleter264 void operator()(cn_cbor* ptr) { cn_cbor_free(ptr); }
265 };
266
267 typedef std::unique_ptr<cn_cbor, CnCborDeleter> CnCborPtr;
268
269 // Simulates the User taping Ok
TEST_P(ConfirmationUIAidlTest,UserOkTest)270 TEST_P(ConfirmationUIAidlTest, UserOkTest) {
271 static constexpr char test_prompt[] = "Me first, gimme gimme!";
272 static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3};
273 shared_ptr<ConfirmationTestCallback> conf_cb =
274 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
275 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
276 vector<uint8_t> extra(test_extra, test_extra + 3);
277 ASSERT_TRUE(confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}).isOk());
278 // Simulate the user taping ok.
279 ASSERT_TRUE(confirmator_->deliverSecureInputEvent(makeTestToken(TestModeCommands::OK_EVENT))
280 .isOk());
281 // Wait for the callback.
282 EXPECT_EQ(std::cv_status::no_timeout, wait());
283 ASSERT_EQ(IConfirmationUI::OK, conf_cb->error_);
284
285 ASSERT_TRUE(conf_cb->verifyConfirmationToken());
286
287 cn_cbor_errback cn_cbor_error;
288 auto parsed_message = CnCborPtr(cn_cbor_decode(
289 conf_cb->formattedMessage_.data(), conf_cb->formattedMessage_.size(), &cn_cbor_error));
290 // is parsable CBOR
291 ASSERT_TRUE(parsed_message.get());
292 // is a map
293 ASSERT_EQ(CN_CBOR_MAP, parsed_message->type);
294
295 // the message must have exactly 2 key value pairs.
296 // cn_cbor holds 2*<no_of_pairs> in the length field
297 ASSERT_EQ(4, parsed_message->length);
298 // map has key "prompt"
299 auto prompt = cn_cbor_mapget_string(parsed_message.get(), "prompt");
300 ASSERT_TRUE(prompt);
301 ASSERT_EQ(CN_CBOR_TEXT, prompt->type);
302 ASSERT_EQ(22, prompt->length);
303 ASSERT_EQ(0, memcmp(test_prompt, prompt->v.str, 22));
304 // map has key "extra"
305 auto extra_out = cn_cbor_mapget_string(parsed_message.get(), "extra");
306 ASSERT_TRUE(extra_out);
307 ASSERT_EQ(CN_CBOR_BYTES, extra_out->type);
308 ASSERT_EQ(3, extra_out->length);
309 ASSERT_EQ(0, memcmp(test_extra, extra_out->v.bytes, 3));
310 }
311
312 // Initiates a confirmation prompt with a message that is too long
TEST_P(ConfirmationUIAidlTest,MessageTooLongTest)313 TEST_P(ConfirmationUIAidlTest, MessageTooLongTest) {
314 static constexpr uint8_t test_extra[IConfirmationUI::MAX_MESSAGE_SIZE] = {};
315 static constexpr char test_prompt[] = "D\'oh!";
316 shared_ptr<ConfirmationTestCallback> conf_cb =
317 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
318 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
319 vector<uint8_t> extra(test_extra, test_extra + sizeof(test_extra));
320 auto result = confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {});
321 ASSERT_EQ(IConfirmationUI::UI_ERROR_MESSAGE_TOO_LONG, getReturnCode(result));
322 }
323
324 // If the message gets very long some HAL implementations might fail even before the message
325 // reaches the trusted app implementation. But the HAL must still diagnose the correct error.
TEST_P(ConfirmationUIAidlTest,MessageWayTooLongTest)326 TEST_P(ConfirmationUIAidlTest, MessageWayTooLongTest) {
327 static constexpr uint8_t test_extra[(IConfirmationUI::MAX_MESSAGE_SIZE)*10] = {};
328 static constexpr char test_prompt[] = "D\'oh!";
329 shared_ptr<ConfirmationTestCallback> conf_cb =
330 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
331 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
332 vector<uint8_t> extra(test_extra, test_extra + sizeof(test_extra));
333 auto result = confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {});
334 ASSERT_EQ(IConfirmationUI::UI_ERROR_MESSAGE_TOO_LONG, getReturnCode(result));
335 }
336
337 // Simulates the User tapping the Cancel
TEST_P(ConfirmationUIAidlTest,UserCancelTest)338 TEST_P(ConfirmationUIAidlTest, UserCancelTest) {
339 static constexpr char test_prompt[] = "Me first, gimme gimme!";
340 static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3};
341 shared_ptr<ConfirmationTestCallback> conf_cb =
342 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
343 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
344 vector<uint8_t> extra(test_extra, test_extra + 3);
345 ASSERT_TRUE(confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}).isOk());
346
347 // Simulate the user taping ok.
348 ASSERT_TRUE(confirmator_->deliverSecureInputEvent(makeTestToken(TestModeCommands::CANCEL_EVENT))
349 .isOk());
350 // Wait for the callback.
351 EXPECT_EQ(std::cv_status::no_timeout, wait());
352 ASSERT_EQ(IConfirmationUI::CANCELED, conf_cb->error_);
353
354 ASSERT_EQ(0U, conf_cb->confirmationToken_.size());
355 ASSERT_EQ(0U, conf_cb->formattedMessage_.size());
356 }
357
358 // Simulates the framework cancelling an ongoing prompt
TEST_P(ConfirmationUIAidlTest,AbortTest)359 TEST_P(ConfirmationUIAidlTest, AbortTest) {
360 static constexpr char test_prompt[] = "Me first, gimme gimme!";
361 static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3};
362 shared_ptr<ConfirmationTestCallback> conf_cb =
363 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
364 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
365 vector<uint8_t> extra(test_extra, test_extra + 3);
366 ASSERT_TRUE(confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}).isOk());
367
368 confirmator_->abort();
369
370 // Wait for the callback.
371 EXPECT_EQ(std::cv_status::no_timeout, wait());
372 ASSERT_EQ(IConfirmationUI::ABORTED, conf_cb->error_);
373 ASSERT_EQ(0U, conf_cb->confirmationToken_.size());
374 ASSERT_EQ(0U, conf_cb->formattedMessage_.size());
375 }
376
377 // Tests if the confirmation dialog can successfully render 100 'W' characters as required by
378 // the design guidelines.
TEST_P(ConfirmationUIAidlTest,PortableMessageTest1)379 TEST_P(ConfirmationUIAidlTest, PortableMessageTest1) {
380 static constexpr char test_prompt[] =
381 "WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW"
382 "WWWWWWWWWWWWWW";
383 static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3};
384 shared_ptr<ConfirmationTestCallback> conf_cb =
385 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
386 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
387 vector<uint8_t> extra(test_extra, test_extra + 3);
388 ASSERT_TRUE(confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}).isOk());
389
390 confirmator_->abort();
391
392 // Wait for the callback.
393 EXPECT_EQ(std::cv_status::no_timeout, wait());
394 ASSERT_EQ(IConfirmationUI::ABORTED, conf_cb->error_);
395 ASSERT_EQ(0U, conf_cb->confirmationToken_.size());
396 ASSERT_EQ(0U, conf_cb->formattedMessage_.size());
397 }
398
399 // Tests if the confirmation dialog can successfully render 100 'W' characters as required by
400 // the design guidelines in magnified mode.
TEST_P(ConfirmationUIAidlTest,PortableMessageTest1Magnified)401 TEST_P(ConfirmationUIAidlTest, PortableMessageTest1Magnified) {
402 static constexpr char test_prompt[] =
403 "WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW"
404 "WWWWWWWWWWWWWW";
405 static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3};
406 shared_ptr<ConfirmationTestCallback> conf_cb =
407 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
408 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
409 vector<uint8_t> extra(test_extra, test_extra + 3);
410 ASSERT_TRUE(confirmator_
411 ->promptUserConfirmation(conf_cb, prompt_text, extra, "en",
412 {UIOption::ACCESSIBILITY_MAGNIFIED})
413 .isOk());
414
415 confirmator_->abort();
416
417 // Wait for the callback.
418 EXPECT_EQ(std::cv_status::no_timeout, wait());
419 ASSERT_EQ(IConfirmationUI::ABORTED, conf_cb->error_);
420 ASSERT_EQ(0U, conf_cb->confirmationToken_.size());
421 ASSERT_EQ(0U, conf_cb->formattedMessage_.size());
422 }
423
424 // Tests if the confirmation dialog can successfully render 8 groups of 12 'W' characters as
425 // required by the design guidelines.
TEST_P(ConfirmationUIAidlTest,PortableMessageTest2)426 TEST_P(ConfirmationUIAidlTest, PortableMessageTest2) {
427 static constexpr char test_prompt[] =
428 "WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW "
429 "WWWWWWWWWWWW WWWWWWWWWWWW";
430 static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3};
431 shared_ptr<ConfirmationTestCallback> conf_cb =
432 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
433 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
434 vector<uint8_t> extra(test_extra, test_extra + 3);
435 ASSERT_TRUE(confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {}).isOk());
436
437 confirmator_->abort();
438
439 // Wait for the callback.
440 EXPECT_EQ(std::cv_status::no_timeout, wait());
441 ASSERT_EQ(IConfirmationUI::ABORTED, conf_cb->error_);
442 ASSERT_EQ(0U, conf_cb->confirmationToken_.size());
443 ASSERT_EQ(0U, conf_cb->formattedMessage_.size());
444 }
445
446 // Tests if the confirmation dialog can successfully render 8 groups of 12 'W' characters as
447 // required by the design guidelines in magnified mode.
TEST_P(ConfirmationUIAidlTest,PortableMessageTest2Magnified)448 TEST_P(ConfirmationUIAidlTest, PortableMessageTest2Magnified) {
449 static constexpr char test_prompt[] =
450 "WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW WWWWWWWWWWWW "
451 "WWWWWWWWWWWW WWWWWWWWWWWW";
452 static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3};
453 shared_ptr<ConfirmationTestCallback> conf_cb =
454 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
455 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
456 vector<uint8_t> extra(test_extra, test_extra + 3);
457 ASSERT_TRUE(confirmator_
458 ->promptUserConfirmation(conf_cb, prompt_text, extra, "en",
459 {UIOption::ACCESSIBILITY_MAGNIFIED})
460 .isOk());
461
462 confirmator_->abort();
463
464 // Wait for the callback.
465 EXPECT_EQ(std::cv_status::no_timeout, wait());
466 ASSERT_EQ(IConfirmationUI::ABORTED, conf_cb->error_);
467 ASSERT_EQ(0U, conf_cb->confirmationToken_.size());
468 ASSERT_EQ(0U, conf_cb->formattedMessage_.size());
469 }
470
471 // Passing malformed UTF-8 to the confirmation UI
472 // This test passes a string that ends in the middle of a multibyte character
TEST_P(ConfirmationUIAidlTest,MalformedUTF8Test1)473 TEST_P(ConfirmationUIAidlTest, MalformedUTF8Test1) {
474 static constexpr char test_prompt[] = {char(0xc0), 0};
475 static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3};
476 shared_ptr<ConfirmationTestCallback> conf_cb =
477 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
478 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
479 vector<uint8_t> extra(test_extra, test_extra + 3);
480 auto result = confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {});
481 ASSERT_EQ(IConfirmationUI::UI_ERROR_MALFORMED_UTF8ENCODING, getReturnCode(result));
482 }
483
484 // Passing malformed UTF-8 to the confirmation UI
485 // This test passes a string with a 5-byte character.
TEST_P(ConfirmationUIAidlTest,MalformedUTF8Test2)486 TEST_P(ConfirmationUIAidlTest, MalformedUTF8Test2) {
487 static constexpr char test_prompt[] = {char(0xf8), char(0x82), char(0x82),
488 char(0x82), char(0x82), 0};
489 static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3};
490 shared_ptr<ConfirmationTestCallback> conf_cb =
491 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
492 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
493 vector<uint8_t> extra(test_extra, test_extra + 3);
494 auto result = confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {});
495 ASSERT_EQ(IConfirmationUI::UI_ERROR_MALFORMED_UTF8ENCODING, getReturnCode(result));
496 }
497
498 // Passing malformed UTF-8 to the confirmation UI
499 // This test passes a string with a 2-byte character followed by a stray non UTF-8 character.
TEST_P(ConfirmationUIAidlTest,MalformedUTF8Test3)500 TEST_P(ConfirmationUIAidlTest, MalformedUTF8Test3) {
501 static constexpr char test_prompt[] = {char(0xc0), char(0x82), char(0x83), 0};
502 static constexpr uint8_t test_extra[] = {0x1, 0x2, 0x3};
503 shared_ptr<ConfirmationTestCallback> conf_cb =
504 ::ndk::SharedRefBase::make<ConfirmationTestCallback>(*this);
505 vector<uint8_t> prompt_text(test_prompt, test_prompt + strlen(test_prompt));
506 vector<uint8_t> extra(test_extra, test_extra + 3);
507 auto result = confirmator_->promptUserConfirmation(conf_cb, prompt_text, extra, "en", {});
508 ASSERT_EQ(IConfirmationUI::UI_ERROR_MALFORMED_UTF8ENCODING, getReturnCode(result));
509 }
510
511 // Test the implementation of HMAC SHA 256 against a golden blob.
TEST(ConfirmationUITestSelfTest,HMAC256SelfTest)512 TEST(ConfirmationUITestSelfTest, HMAC256SelfTest) {
513 const char key_str[32] = "keykeykeykeykeykeykeykeykeykeyk";
514 const uint8_t(&key)[32] = *reinterpret_cast<const uint8_t(*)[32]>(key_str);
515 auto expected = hex2str("2377fbcaa7fb3f6c20cfa1d9ebc60e9922cf58c909e25e300f3cb57f7805c886");
516 auto result = HMacer::hmac256(key, "value1", "value2", "value3");
517
518 #ifdef DEBUG_CONFRIMATIONUI_UTILS_TEST
519 hexdump(std::cout, reinterpret_cast<const uint8_t*>(expected.data()), 32) << std::endl;
520 hexdump(std::cout, result.value().data(), 32) << std::endl;
521 #endif
522
523 ByteBufferProxy expected_bytes(expected);
524 ASSERT_TRUE(result.isOk());
525 ASSERT_EQ(expected, result.value());
526 }
527
528 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ConfirmationUIAidlTest);
529 INSTANTIATE_TEST_SUITE_P(
530 PerInstance, ConfirmationUIAidlTest,
531 testing::ValuesIn(::android::getAidlHalInstanceNames(IConfirmationUI::descriptor)),
532 ::android::PrintInstanceNameToString);
533
534 } // namespace aidl::android::hardware::confirmationui::test
535
main(int argc,char ** argv)536 int main(int argc, char** argv) {
537 ::testing::InitGoogleTest(&argc, argv);
538 ABinderProcess_setThreadPoolMaxThreadCount(1);
539 ABinderProcess_startThreadPool();
540 return RUN_ALL_TESTS();
541 }
542