tpm_token_info_getter_unittest.cc 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ash/components/tpm/tpm_token_info_getter.h"
  5. #include <stdint.h>
  6. #include <memory>
  7. #include <string>
  8. #include <utility>
  9. #include <vector>
  10. #include "base/bind.h"
  11. #include "base/location.h"
  12. #include "base/run_loop.h"
  13. #include "base/task/single_thread_task_runner.h"
  14. #include "base/task/task_runner.h"
  15. #include "base/test/task_environment.h"
  16. #include "base/threading/thread_task_runner_handle.h"
  17. #include "chromeos/ash/components/cryptohome/cryptohome_parameters.h"
  18. #include "chromeos/ash/components/dbus/userdataauth/cryptohome_pkcs11_client.h"
  19. #include "chromeos/ash/components/dbus/userdataauth/fake_cryptohome_pkcs11_client.h"
  20. #include "chromeos/dbus/tpm_manager/tpm_manager_client.h"
  21. #include "testing/gtest/include/gtest/gtest.h"
  22. #include "third_party/abseil-cpp/absl/types/optional.h"
  23. namespace ash {
  24. namespace {
  25. using ::user_data_auth::TpmTokenInfo;
  26. // On invocation, set |called| to true, and store the result |token_info|
  27. // to the |result|.
  28. void OnTpmTokenInfoGetterCompleted(bool* called,
  29. absl::optional<TpmTokenInfo>* result,
  30. absl::optional<TpmTokenInfo> token_info) {
  31. DCHECK(called);
  32. DCHECK(result);
  33. *called = true;
  34. *result = std::move(token_info);
  35. }
  36. // Task runner for handling delayed tasks posted by TPMTokenInfoGetter when
  37. // retrying failed cryptohome method calls. It just records the requested
  38. // delay and immediately runs the task. The task is run asynchronously to be
  39. // closer to what's actually happening in production.
  40. // The delays used by TPMTokenGetter should be monotonically increasing, so
  41. // the fake task runner does not handle task reordering based on the delays.
  42. class FakeTaskRunner : public base::TaskRunner {
  43. public:
  44. // |delays|: Vector to which the dalays seen by the task runner are saved.
  45. explicit FakeTaskRunner(std::vector<int64_t>* delays) : delays_(delays) {}
  46. FakeTaskRunner(const FakeTaskRunner&) = delete;
  47. FakeTaskRunner& operator=(const FakeTaskRunner&) = delete;
  48. // base::TaskRunner overrides:
  49. bool PostDelayedTask(const base::Location& from_here,
  50. base::OnceClosure task,
  51. base::TimeDelta delay) override {
  52. delays_->push_back(delay.InMilliseconds());
  53. base::ThreadTaskRunnerHandle::Get()->PostTask(from_here, std::move(task));
  54. return true;
  55. }
  56. protected:
  57. ~FakeTaskRunner() override = default;
  58. private:
  59. // The vector of delays.
  60. std::vector<int64_t>* delays_;
  61. };
  62. // Implementation of CryptohomePkcs11Client used in these tests.
  63. // TestCryptohomePkcs11Client overrides all CryptohomePkcs11Client methods used
  64. // in TPMTokenInfoGetter tests.
  65. class TestCryptohomePkcs11Client : public FakeCryptohomePkcs11Client {
  66. public:
  67. // |account_id|: The user associated with the TPMTokenInfoGetter that will be
  68. // using the TestCryptohomePkcs11Client. Should be empty for system token.
  69. explicit TestCryptohomePkcs11Client(const AccountId& account_id)
  70. : account_id_(account_id),
  71. get_tpm_token_info_failure_count_(0),
  72. get_tpm_token_info_not_set_count_(0),
  73. get_tpm_token_info_succeeded_(false) {}
  74. TestCryptohomePkcs11Client(const TestCryptohomePkcs11Client&) = delete;
  75. TestCryptohomePkcs11Client& operator=(const TestCryptohomePkcs11Client&) =
  76. delete;
  77. ~TestCryptohomePkcs11Client() override = default;
  78. void set_get_tpm_token_info_failure_count(int value) {
  79. ASSERT_GT(value, 0);
  80. get_tpm_token_info_failure_count_ = value;
  81. }
  82. void set_get_tpm_token_info_not_set_count(int value) {
  83. ASSERT_GT(value, 0);
  84. get_tpm_token_info_not_set_count_ = value;
  85. }
  86. // Sets the tpm tpken info to be reported by the test CryptohomePkcs11Client.
  87. // If there is |Pkcs11GetTpmTokenInfo| in progress, runs the pending
  88. // callback with the set tpm token info.
  89. void SetTpmTokenInfo(const TpmTokenInfo& token_info) {
  90. tpm_token_info_ = token_info;
  91. ASSERT_NE(-1, tpm_token_info_->slot());
  92. InvokeGetTpmTokenInfoCallbackIfReady();
  93. }
  94. private:
  95. // FakeCryptohomePkcs11Client override.
  96. void Pkcs11GetTpmTokenInfo(
  97. const ::user_data_auth::Pkcs11GetTpmTokenInfoRequest& request,
  98. Pkcs11GetTpmTokenInfoCallback callback) override {
  99. if (request.username().empty()) {
  100. ASSERT_TRUE(account_id_.empty());
  101. } else {
  102. ASSERT_EQ(cryptohome::CreateAccountIdentifierFromAccountId(account_id_)
  103. .account_id(),
  104. request.username());
  105. }
  106. HandleGetTpmTokenInfo(std::move(callback));
  107. }
  108. // Handles Pkcs11GetTpmTokenInfo calls (both for system and user token). The
  109. // CryptohomePkcs11Client method overrides should make sure that |account_id_|
  110. // is properly set before calling this.
  111. void HandleGetTpmTokenInfo(
  112. chromeos::DBusMethodCallback<::user_data_auth::Pkcs11GetTpmTokenInfoReply>
  113. callback) {
  114. ASSERT_FALSE(get_tpm_token_info_succeeded_);
  115. ASSERT_TRUE(pending_get_tpm_token_info_callback_.is_null());
  116. if (get_tpm_token_info_failure_count_ > 0) {
  117. --get_tpm_token_info_failure_count_;
  118. base::ThreadTaskRunnerHandle::Get()->PostTask(
  119. FROM_HERE, base::BindOnce(std::move(callback), absl::nullopt));
  120. return;
  121. }
  122. if (get_tpm_token_info_not_set_count_ > 0) {
  123. --get_tpm_token_info_not_set_count_;
  124. ::user_data_auth::Pkcs11GetTpmTokenInfoReply reply;
  125. reply.mutable_token_info()->set_slot(-1);
  126. base::ThreadTaskRunnerHandle::Get()->PostTask(
  127. FROM_HERE, base::BindOnce(std::move(callback), reply));
  128. return;
  129. }
  130. pending_get_tpm_token_info_callback_ = std::move(callback);
  131. InvokeGetTpmTokenInfoCallbackIfReady();
  132. }
  133. void InvokeGetTpmTokenInfoCallbackIfReady() {
  134. if (!tpm_token_info_.has_value() || tpm_token_info_->slot() == -1 ||
  135. pending_get_tpm_token_info_callback_.is_null())
  136. return;
  137. get_tpm_token_info_succeeded_ = true;
  138. // Called synchronously for convenience (to avoid using extra RunLoop in
  139. // tests). Unlike with other Cryptohome callbacks, TPMTokenInfoGetter does
  140. // not rely on this callback being called asynchronously.
  141. ::user_data_auth::Pkcs11GetTpmTokenInfoReply reply;
  142. reply.mutable_token_info()->CopyFrom(tpm_token_info_.value());
  143. std::move(pending_get_tpm_token_info_callback_).Run(reply);
  144. }
  145. AccountId account_id_;
  146. int get_tpm_token_info_failure_count_;
  147. int get_tpm_token_info_not_set_count_;
  148. bool get_tpm_token_info_succeeded_;
  149. chromeos::DBusMethodCallback<::user_data_auth::Pkcs11GetTpmTokenInfoReply>
  150. pending_get_tpm_token_info_callback_;
  151. absl::optional<TpmTokenInfo> tpm_token_info_;
  152. };
  153. class SystemTPMTokenInfoGetterTest : public testing::Test {
  154. public:
  155. SystemTPMTokenInfoGetterTest() { TpmManagerClient::Get()->InitializeFake(); }
  156. SystemTPMTokenInfoGetterTest(const SystemTPMTokenInfoGetterTest&) = delete;
  157. SystemTPMTokenInfoGetterTest& operator=(const SystemTPMTokenInfoGetterTest&) =
  158. delete;
  159. ~SystemTPMTokenInfoGetterTest() override {
  160. TpmManagerClient::Get()->Shutdown();
  161. }
  162. void SetUp() override {
  163. cryptohome_client_ =
  164. std::make_unique<TestCryptohomePkcs11Client>(EmptyAccountId());
  165. tpm_token_info_getter_ = TPMTokenInfoGetter::CreateForSystemToken(
  166. cryptohome_client_.get(),
  167. scoped_refptr<base::TaskRunner>(new FakeTaskRunner(&delays_)));
  168. }
  169. protected:
  170. std::unique_ptr<TestCryptohomePkcs11Client> cryptohome_client_;
  171. std::unique_ptr<TPMTokenInfoGetter> tpm_token_info_getter_;
  172. std::vector<int64_t> delays_;
  173. private:
  174. base::test::SingleThreadTaskEnvironment task_environment_;
  175. };
  176. class UserTPMTokenInfoGetterTest : public testing::Test {
  177. public:
  178. UserTPMTokenInfoGetterTest()
  179. : account_id_(AccountId::FromUserEmail("user@gmail.com")) {
  180. TpmManagerClient::Get()->InitializeFake();
  181. }
  182. UserTPMTokenInfoGetterTest(const UserTPMTokenInfoGetterTest&) = delete;
  183. UserTPMTokenInfoGetterTest& operator=(const UserTPMTokenInfoGetterTest&) =
  184. delete;
  185. ~UserTPMTokenInfoGetterTest() override {
  186. TpmManagerClient::Get()->Shutdown();
  187. }
  188. void SetUp() override {
  189. cryptohome_client_ =
  190. std::make_unique<TestCryptohomePkcs11Client>(account_id_);
  191. tpm_token_info_getter_ = TPMTokenInfoGetter::CreateForUserToken(
  192. account_id_, cryptohome_client_.get(),
  193. scoped_refptr<base::TaskRunner>(new FakeTaskRunner(&delays_)));
  194. tpm_token_info_getter_->set_nss_slots_software_fallback_for_testing(false);
  195. }
  196. protected:
  197. std::unique_ptr<TestCryptohomePkcs11Client> cryptohome_client_;
  198. std::unique_ptr<TPMTokenInfoGetter> tpm_token_info_getter_;
  199. const AccountId account_id_;
  200. std::vector<int64_t> delays_;
  201. private:
  202. base::test::SingleThreadTaskEnvironment task_environment_;
  203. };
  204. TEST_F(SystemTPMTokenInfoGetterTest, BasicFlow) {
  205. bool completed = false;
  206. absl::optional<TpmTokenInfo> result;
  207. tpm_token_info_getter_->Start(
  208. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  209. base::RunLoop().RunUntilIdle();
  210. EXPECT_FALSE(completed);
  211. TpmTokenInfo fake_token_info;
  212. fake_token_info.set_label("TOKEN_1");
  213. fake_token_info.set_user_pin("2222");
  214. fake_token_info.set_slot(1);
  215. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  216. EXPECT_TRUE(completed);
  217. ASSERT_TRUE(result.has_value());
  218. EXPECT_EQ("TOKEN_1", result->label());
  219. EXPECT_EQ("2222", result->user_pin());
  220. EXPECT_EQ(1, result->slot());
  221. EXPECT_EQ(std::vector<int64_t>(), delays_);
  222. }
  223. TEST_F(SystemTPMTokenInfoGetterTest, TokenSlotIdEqualsZero) {
  224. bool completed = false;
  225. absl::optional<TpmTokenInfo> result;
  226. tpm_token_info_getter_->Start(
  227. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  228. base::RunLoop().RunUntilIdle();
  229. EXPECT_FALSE(completed);
  230. TpmTokenInfo fake_token_info;
  231. fake_token_info.set_label("TOKEN_0");
  232. fake_token_info.set_user_pin("2222");
  233. fake_token_info.set_slot(0);
  234. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  235. EXPECT_TRUE(completed);
  236. ASSERT_TRUE(result.has_value());
  237. EXPECT_EQ("TOKEN_0", result->label());
  238. EXPECT_EQ("2222", result->user_pin());
  239. EXPECT_EQ(0, result->slot());
  240. EXPECT_EQ(std::vector<int64_t>(), delays_);
  241. }
  242. TEST_F(SystemTPMTokenInfoGetterTest, TPMNotEnabled) {
  243. TpmManagerClient::Get()
  244. ->GetTestInterface()
  245. ->mutable_nonsensitive_status_reply()
  246. ->set_is_enabled(false);
  247. bool completed = false;
  248. absl::optional<TpmTokenInfo> result;
  249. tpm_token_info_getter_->Start(
  250. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  251. base::RunLoop().RunUntilIdle();
  252. EXPECT_TRUE(completed);
  253. EXPECT_EQ(std::vector<int64_t>(), delays_);
  254. }
  255. TEST_F(SystemTPMTokenInfoGetterTest, TPMNotOwnedSystemSlotFallbackEnabled) {
  256. TpmManagerClient::Get()
  257. ->GetTestInterface()
  258. ->mutable_nonsensitive_status_reply()
  259. ->set_is_enabled(false);
  260. TpmManagerClient::Get()
  261. ->GetTestInterface()
  262. ->mutable_nonsensitive_status_reply()
  263. ->set_is_owned(false);
  264. bool completed = false;
  265. absl::optional<TpmTokenInfo> result;
  266. tpm_token_info_getter_->set_nss_slots_software_fallback_for_testing(true);
  267. tpm_token_info_getter_->Start(
  268. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  269. base::RunLoop().RunUntilIdle();
  270. EXPECT_FALSE(completed);
  271. TpmTokenInfo fake_token_info;
  272. fake_token_info.set_label("TOKEN_1");
  273. fake_token_info.set_user_pin("2222");
  274. fake_token_info.set_slot(1);
  275. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  276. EXPECT_TRUE(completed);
  277. ASSERT_TRUE(result.has_value());
  278. EXPECT_EQ("TOKEN_1", result->label());
  279. EXPECT_EQ("2222", result->user_pin());
  280. EXPECT_EQ(1, result->slot());
  281. EXPECT_EQ(std::vector<int64_t>(), delays_);
  282. }
  283. TEST_F(SystemTPMTokenInfoGetterTest, TPMOwnedSystemSlotFallbackEnabled) {
  284. TpmManagerClient::Get()
  285. ->GetTestInterface()
  286. ->mutable_nonsensitive_status_reply()
  287. ->set_is_enabled(true);
  288. TpmManagerClient::Get()
  289. ->GetTestInterface()
  290. ->mutable_nonsensitive_status_reply()
  291. ->set_is_owned(true);
  292. bool completed = false;
  293. absl::optional<TpmTokenInfo> result;
  294. tpm_token_info_getter_->set_nss_slots_software_fallback_for_testing(true);
  295. tpm_token_info_getter_->Start(
  296. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  297. base::RunLoop().RunUntilIdle();
  298. EXPECT_FALSE(completed);
  299. TpmTokenInfo fake_token_info;
  300. fake_token_info.set_label("TOKEN_1");
  301. fake_token_info.set_user_pin("2222");
  302. fake_token_info.set_slot(1);
  303. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  304. EXPECT_TRUE(completed);
  305. ASSERT_TRUE(result.has_value());
  306. EXPECT_EQ("TOKEN_1", result->label());
  307. EXPECT_EQ("2222", result->user_pin());
  308. EXPECT_EQ(1, result->slot());
  309. EXPECT_EQ(std::vector<int64_t>(), delays_);
  310. }
  311. TEST_F(SystemTPMTokenInfoGetterTest, TpmEnabledCallFails) {
  312. TpmManagerClient::Get()
  313. ->GetTestInterface()
  314. ->set_non_nonsensitive_status_dbus_error_count(1);
  315. bool completed = false;
  316. absl::optional<TpmTokenInfo> result;
  317. tpm_token_info_getter_->Start(
  318. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  319. base::RunLoop().RunUntilIdle();
  320. EXPECT_FALSE(completed);
  321. TpmTokenInfo fake_token_info;
  322. fake_token_info.set_label("TOKEN_1");
  323. fake_token_info.set_user_pin("2222");
  324. fake_token_info.set_slot(1);
  325. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  326. EXPECT_TRUE(completed);
  327. ASSERT_TRUE(result.has_value());
  328. EXPECT_EQ("TOKEN_1", result->label());
  329. EXPECT_EQ("2222", result->user_pin());
  330. EXPECT_EQ(1, result->slot());
  331. const int64_t kExpectedDelays[] = {100};
  332. EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
  333. kExpectedDelays + std::size(kExpectedDelays)),
  334. delays_);
  335. }
  336. TEST_F(SystemTPMTokenInfoGetterTest, GetTpmTokenInfoInitiallyNotReady) {
  337. cryptohome_client_->set_get_tpm_token_info_not_set_count(1);
  338. bool completed = false;
  339. absl::optional<TpmTokenInfo> result;
  340. tpm_token_info_getter_->Start(
  341. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  342. base::RunLoop().RunUntilIdle();
  343. EXPECT_FALSE(completed);
  344. TpmTokenInfo fake_token_info;
  345. fake_token_info.set_label("TOKEN_1");
  346. fake_token_info.set_user_pin("2222");
  347. fake_token_info.set_slot(1);
  348. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  349. EXPECT_TRUE(completed);
  350. ASSERT_TRUE(result.has_value());
  351. EXPECT_EQ("TOKEN_1", result->label());
  352. EXPECT_EQ("2222", result->user_pin());
  353. EXPECT_EQ(1, result->slot());
  354. const int64_t kExpectedDelays[] = {100};
  355. EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
  356. kExpectedDelays + std::size(kExpectedDelays)),
  357. delays_);
  358. }
  359. TEST_F(SystemTPMTokenInfoGetterTest, GetTpmTokenInfoInitiallyFails) {
  360. cryptohome_client_->set_get_tpm_token_info_failure_count(1);
  361. bool completed = false;
  362. absl::optional<TpmTokenInfo> result;
  363. tpm_token_info_getter_->Start(
  364. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  365. base::RunLoop().RunUntilIdle();
  366. EXPECT_FALSE(completed);
  367. TpmTokenInfo fake_token_info;
  368. fake_token_info.set_label("TOKEN_1");
  369. fake_token_info.set_user_pin("2222");
  370. fake_token_info.set_slot(1);
  371. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  372. EXPECT_TRUE(completed);
  373. ASSERT_TRUE(result.has_value());
  374. EXPECT_EQ("TOKEN_1", result->label());
  375. EXPECT_EQ("2222", result->user_pin());
  376. EXPECT_EQ(1, result->slot());
  377. const int64_t kExpectedDelays[] = {100};
  378. EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
  379. kExpectedDelays + std::size(kExpectedDelays)),
  380. delays_);
  381. }
  382. TEST_F(SystemTPMTokenInfoGetterTest, RetryDelaysIncreaseExponentially) {
  383. TpmManagerClient::Get()
  384. ->GetTestInterface()
  385. ->set_non_nonsensitive_status_dbus_error_count(2);
  386. cryptohome_client_->set_get_tpm_token_info_failure_count(1);
  387. cryptohome_client_->set_get_tpm_token_info_not_set_count(3);
  388. bool completed = false;
  389. absl::optional<TpmTokenInfo> result;
  390. tpm_token_info_getter_->Start(
  391. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  392. base::RunLoop().RunUntilIdle();
  393. EXPECT_FALSE(completed);
  394. TpmTokenInfo fake_token_info;
  395. fake_token_info.set_label("TOKEN_1");
  396. fake_token_info.set_user_pin("2222");
  397. fake_token_info.set_slot(1);
  398. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  399. EXPECT_TRUE(completed);
  400. ASSERT_TRUE(result.has_value());
  401. EXPECT_EQ("TOKEN_1", result->label());
  402. EXPECT_EQ("2222", result->user_pin());
  403. EXPECT_EQ(1, result->slot());
  404. int64_t kExpectedDelays[] = {100, 200, 400, 800, 1600, 3200};
  405. ASSERT_EQ(std::vector<int64_t>(kExpectedDelays,
  406. kExpectedDelays + std::size(kExpectedDelays)),
  407. delays_);
  408. }
  409. TEST_F(SystemTPMTokenInfoGetterTest, RetryDelayBounded) {
  410. TpmManagerClient::Get()
  411. ->GetTestInterface()
  412. ->set_non_nonsensitive_status_dbus_error_count(4);
  413. cryptohome_client_->set_get_tpm_token_info_failure_count(5);
  414. cryptohome_client_->set_get_tpm_token_info_not_set_count(6);
  415. bool completed = false;
  416. absl::optional<TpmTokenInfo> result;
  417. tpm_token_info_getter_->Start(
  418. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  419. base::RunLoop().RunUntilIdle();
  420. EXPECT_FALSE(completed);
  421. TpmTokenInfo fake_token_info;
  422. fake_token_info.set_label("TOKEN_1");
  423. fake_token_info.set_user_pin("2222");
  424. fake_token_info.set_slot(1);
  425. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  426. EXPECT_TRUE(completed);
  427. ASSERT_TRUE(result.has_value());
  428. EXPECT_EQ("TOKEN_1", result->label());
  429. EXPECT_EQ("2222", result->user_pin());
  430. EXPECT_EQ(1, result->slot());
  431. int64_t kExpectedDelays[] = {100, 200, 400, 800, 1600,
  432. 3200, 6400, 12800, 25600, 51200,
  433. 102400, 204800, 300000, 300000, 300000};
  434. ASSERT_EQ(std::vector<int64_t>(kExpectedDelays,
  435. kExpectedDelays + std::size(kExpectedDelays)),
  436. delays_);
  437. }
  438. TEST_F(UserTPMTokenInfoGetterTest, BasicFlow) {
  439. bool completed = false;
  440. absl::optional<TpmTokenInfo> result;
  441. tpm_token_info_getter_->Start(
  442. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  443. base::RunLoop().RunUntilIdle();
  444. EXPECT_FALSE(completed);
  445. TpmTokenInfo fake_token_info;
  446. fake_token_info.set_label("TOKEN_1");
  447. fake_token_info.set_user_pin("2222");
  448. fake_token_info.set_slot(1);
  449. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  450. EXPECT_TRUE(completed);
  451. ASSERT_TRUE(result.has_value());
  452. EXPECT_EQ("TOKEN_1", result->label());
  453. EXPECT_EQ("2222", result->user_pin());
  454. EXPECT_EQ(1, result->slot());
  455. EXPECT_EQ(std::vector<int64_t>(), delays_);
  456. }
  457. TEST_F(UserTPMTokenInfoGetterTest, GetTpmTokenInfoInitiallyFails) {
  458. cryptohome_client_->set_get_tpm_token_info_failure_count(1);
  459. bool completed = false;
  460. absl::optional<TpmTokenInfo> result;
  461. tpm_token_info_getter_->Start(
  462. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  463. base::RunLoop().RunUntilIdle();
  464. EXPECT_FALSE(completed);
  465. TpmTokenInfo fake_token_info;
  466. fake_token_info.set_label("TOKEN_1");
  467. fake_token_info.set_user_pin("2222");
  468. fake_token_info.set_slot(1);
  469. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  470. EXPECT_TRUE(completed);
  471. ASSERT_TRUE(result.has_value());
  472. EXPECT_EQ("TOKEN_1", result->label());
  473. EXPECT_EQ("2222", result->user_pin());
  474. EXPECT_EQ(1, result->slot());
  475. const int64_t kExpectedDelays[] = {100};
  476. EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
  477. kExpectedDelays + std::size(kExpectedDelays)),
  478. delays_);
  479. }
  480. TEST_F(UserTPMTokenInfoGetterTest, GetTpmTokenInfoInitiallyNotReady) {
  481. cryptohome_client_->set_get_tpm_token_info_not_set_count(1);
  482. bool completed = false;
  483. absl::optional<TpmTokenInfo> result;
  484. tpm_token_info_getter_->Start(
  485. base::BindOnce(&OnTpmTokenInfoGetterCompleted, &completed, &result));
  486. base::RunLoop().RunUntilIdle();
  487. EXPECT_FALSE(completed);
  488. TpmTokenInfo fake_token_info;
  489. fake_token_info.set_label("TOKEN_1");
  490. fake_token_info.set_user_pin("2222");
  491. fake_token_info.set_slot(1);
  492. cryptohome_client_->SetTpmTokenInfo(fake_token_info);
  493. EXPECT_TRUE(completed);
  494. ASSERT_TRUE(result.has_value());
  495. EXPECT_EQ("TOKEN_1", result->label());
  496. EXPECT_EQ("2222", result->user_pin());
  497. EXPECT_EQ(1, result->slot());
  498. const int64_t kExpectedDelays[] = {100};
  499. EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
  500. kExpectedDelays + std::size(kExpectedDelays)),
  501. delays_);
  502. }
  503. } // namespace
  504. } // namespace ash