fido_parsing_utils_unittest.cc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286
  1. // Copyright 2018 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 "device/fido/fido_parsing_utils.h"
  5. #include "device/fido/fido_test_data.h"
  6. #include "testing/gmock/include/gmock/gmock.h"
  7. #include "testing/gtest/include/gtest/gtest.h"
  8. namespace device {
  9. namespace fido_parsing_utils {
  10. namespace {
  11. constexpr uint8_t kOne[] = {0x01};
  12. constexpr uint8_t kOneTwo[] = {0x01, 0x02};
  13. constexpr uint8_t kTwo[] = {0x02};
  14. constexpr uint8_t kTwoThree[] = {0x02, 0x03};
  15. constexpr uint8_t kThree[] = {0x03};
  16. constexpr uint8_t kOneTwoThree[] = {0x01, 0x02, 0x03};
  17. } // namespace
  18. TEST(U2fParsingUtils, RangeLess) {
  19. const std::array<int, 4> kOneTwoThreeFour = {1, 2, 3, 4};
  20. EXPECT_FALSE(RangeLess()(kOne, kOne));
  21. EXPECT_TRUE(RangeLess()(kOne, kOneTwo));
  22. EXPECT_TRUE(RangeLess()(kOne, kTwo));
  23. EXPECT_TRUE(RangeLess()(kOne, kTwoThree));
  24. EXPECT_TRUE(RangeLess()(kOne, kThree));
  25. EXPECT_TRUE(RangeLess()(kOne, kOneTwoThree));
  26. EXPECT_TRUE(RangeLess()(kOne, kOneTwoThreeFour));
  27. EXPECT_FALSE(RangeLess()(kOneTwo, kOne));
  28. EXPECT_FALSE(RangeLess()(kOneTwo, kOneTwo));
  29. EXPECT_TRUE(RangeLess()(kOneTwo, kTwo));
  30. EXPECT_TRUE(RangeLess()(kOneTwo, kTwoThree));
  31. EXPECT_TRUE(RangeLess()(kOneTwo, kThree));
  32. EXPECT_TRUE(RangeLess()(kOneTwo, kOneTwoThree));
  33. EXPECT_TRUE(RangeLess()(kOneTwo, kOneTwoThreeFour));
  34. EXPECT_FALSE(RangeLess()(kTwo, kOne));
  35. EXPECT_FALSE(RangeLess()(kTwo, kOneTwo));
  36. EXPECT_FALSE(RangeLess()(kTwo, kTwo));
  37. EXPECT_TRUE(RangeLess()(kTwo, kTwoThree));
  38. EXPECT_TRUE(RangeLess()(kTwo, kThree));
  39. EXPECT_FALSE(RangeLess()(kTwo, kOneTwoThree));
  40. EXPECT_FALSE(RangeLess()(kTwo, kOneTwoThreeFour));
  41. EXPECT_FALSE(RangeLess()(kTwoThree, kOne));
  42. EXPECT_FALSE(RangeLess()(kTwoThree, kOneTwo));
  43. EXPECT_FALSE(RangeLess()(kTwoThree, kTwo));
  44. EXPECT_FALSE(RangeLess()(kTwoThree, kTwoThree));
  45. EXPECT_TRUE(RangeLess()(kTwoThree, kThree));
  46. EXPECT_FALSE(RangeLess()(kTwoThree, kOneTwoThree));
  47. EXPECT_FALSE(RangeLess()(kTwoThree, kOneTwoThreeFour));
  48. EXPECT_FALSE(RangeLess()(kThree, kOne));
  49. EXPECT_FALSE(RangeLess()(kThree, kOneTwo));
  50. EXPECT_FALSE(RangeLess()(kThree, kTwo));
  51. EXPECT_FALSE(RangeLess()(kThree, kTwoThree));
  52. EXPECT_FALSE(RangeLess()(kThree, kThree));
  53. EXPECT_FALSE(RangeLess()(kThree, kOneTwoThree));
  54. EXPECT_FALSE(RangeLess()(kThree, kOneTwoThreeFour));
  55. EXPECT_FALSE(RangeLess()(kOneTwoThree, kOne));
  56. EXPECT_FALSE(RangeLess()(kOneTwoThree, kOneTwo));
  57. EXPECT_TRUE(RangeLess()(kOneTwoThree, kTwo));
  58. EXPECT_TRUE(RangeLess()(kOneTwoThree, kTwoThree));
  59. EXPECT_TRUE(RangeLess()(kOneTwoThree, kThree));
  60. EXPECT_FALSE(RangeLess()(kOneTwoThree, kOneTwoThree));
  61. EXPECT_TRUE(RangeLess()(kOneTwoThree, kOneTwoThreeFour));
  62. EXPECT_FALSE(RangeLess()(kOneTwoThreeFour, kOne));
  63. EXPECT_FALSE(RangeLess()(kOneTwoThreeFour, kOneTwo));
  64. EXPECT_TRUE(RangeLess()(kOneTwoThreeFour, kTwo));
  65. EXPECT_TRUE(RangeLess()(kOneTwoThreeFour, kTwoThree));
  66. EXPECT_TRUE(RangeLess()(kOneTwoThreeFour, kThree));
  67. EXPECT_FALSE(RangeLess()(kOneTwoThreeFour, kOneTwoThree));
  68. EXPECT_FALSE(RangeLess()(kOneTwoThreeFour, kOneTwoThreeFour));
  69. }
  70. TEST(U2fParsingUtils, Materialize) {
  71. const std::vector<uint8_t> empty;
  72. EXPECT_THAT(Materialize(empty), ::testing::IsEmpty());
  73. EXPECT_THAT(Materialize(base::span<const uint8_t>()), ::testing::IsEmpty());
  74. EXPECT_THAT(Materialize(base::span<const uint8_t>(kOne)),
  75. ::testing::ElementsAreArray(kOne));
  76. EXPECT_THAT(Materialize(base::span<const uint8_t>(kOneTwoThree)),
  77. ::testing::ElementsAreArray(kOneTwoThree));
  78. static_assert(std::is_same<std::vector<uint8_t>,
  79. decltype(Materialize(
  80. base::span<const uint8_t>(kOne)))>::value,
  81. "Materialize with a dynamic span should yield a std::vector.");
  82. }
  83. TEST(U2fParsingUtils, StaticMaterialize) {
  84. std::array<uint8_t, 0> empty;
  85. EXPECT_THAT(Materialize(empty), ::testing::IsEmpty());
  86. EXPECT_THAT(Materialize(base::span<const uint8_t, 0>()),
  87. ::testing::IsEmpty());
  88. EXPECT_THAT(Materialize(base::make_span(kOne)),
  89. ::testing::ElementsAreArray(kOne));
  90. EXPECT_THAT(Materialize(base::make_span(kOneTwoThree)),
  91. ::testing::ElementsAreArray(kOneTwoThree));
  92. static_assert(
  93. std::is_same<std::array<uint8_t, 1>,
  94. decltype(Materialize(base::make_span(kOne)))>::value,
  95. "Materialize with a static span should yield a std::array.");
  96. }
  97. TEST(U2fParsingUtils, MaterializeOrNull) {
  98. auto result = MaterializeOrNull(kOneTwoThree);
  99. ASSERT_TRUE(result.has_value());
  100. EXPECT_THAT(*result, ::testing::ElementsAreArray(kOneTwoThree));
  101. EXPECT_EQ(MaterializeOrNull(absl::nullopt), absl::nullopt);
  102. }
  103. TEST(U2fParsingUtils, Append) {
  104. std::vector<uint8_t> target;
  105. Append(&target, base::span<const uint8_t>());
  106. EXPECT_THAT(target, ::testing::IsEmpty());
  107. // Should be idempotent, try twice for good measure.
  108. Append(&target, base::span<const uint8_t>());
  109. EXPECT_THAT(target, ::testing::IsEmpty());
  110. const std::vector<uint8_t> one(std::begin(kOne), std::end(kOne));
  111. Append(&target, one);
  112. EXPECT_THAT(target, ::testing::ElementsAreArray(kOne));
  113. Append(&target, kTwoThree);
  114. EXPECT_THAT(target, ::testing::ElementsAreArray(kOneTwoThree));
  115. }
  116. TEST(U2fParsingUtils, AppendSelfCrashes) {
  117. std::vector<uint8_t> target(std::begin(kOneTwoThree), std::end(kOneTwoThree));
  118. auto span = base::make_span(target);
  119. // Tests the case where |in_values| overlap with the beginning of |*target|.
  120. EXPECT_DEATH_IF_SUPPORTED(Append(&target, span.first(1)), "");
  121. // Tests the case where |in_values| overlap with the end of |*target|.
  122. EXPECT_DEATH_IF_SUPPORTED(Append(&target, span.last(1)), "");
  123. }
  124. // ExtractSpan and ExtractSuffixSpan are implicitly tested as they used by
  125. // the Extract and ExtractSuffix implementations.
  126. TEST(U2fParsingUtils, ExtractEmpty) {
  127. const std::vector<uint8_t> empty;
  128. EXPECT_THAT(Extract(empty, 0, 0), ::testing::IsEmpty());
  129. EXPECT_THAT(Extract(kOne, 0, 0), ::testing::IsEmpty());
  130. EXPECT_THAT(Extract(kOne, 1, 0), ::testing::IsEmpty());
  131. EXPECT_THAT(Extract(kOneTwoThree, 0, 0), ::testing::IsEmpty());
  132. EXPECT_THAT(Extract(kOneTwoThree, 1, 0), ::testing::IsEmpty());
  133. EXPECT_THAT(Extract(kOneTwoThree, 2, 0), ::testing::IsEmpty());
  134. EXPECT_THAT(Extract(kOneTwoThree, 3, 0), ::testing::IsEmpty());
  135. }
  136. TEST(U2fParsingUtils, ExtractInBounds) {
  137. EXPECT_THAT(Extract(kOne, 0, 1), ::testing::ElementsAreArray(kOne));
  138. EXPECT_THAT(Extract(kOneTwoThree, 0, 1), ::testing::ElementsAreArray(kOne));
  139. EXPECT_THAT(Extract(kOneTwoThree, 2, 1), ::testing::ElementsAreArray(kThree));
  140. EXPECT_THAT(Extract(kOneTwoThree, 1, 2),
  141. ::testing::ElementsAreArray(kTwoThree));
  142. EXPECT_THAT(Extract(kOneTwoThree, 0, 3),
  143. ::testing::ElementsAreArray(kOneTwoThree));
  144. }
  145. TEST(U2fParsingUtils, ExtractOutOfBounds) {
  146. const std::vector<uint8_t> empty;
  147. EXPECT_THAT(Extract(empty, 0, 1), ::testing::IsEmpty());
  148. EXPECT_THAT(Extract(empty, 1, 0), ::testing::IsEmpty());
  149. EXPECT_THAT(Extract(kOne, 0, 2), ::testing::IsEmpty());
  150. EXPECT_THAT(Extract(kOne, 1, 1), ::testing::IsEmpty());
  151. EXPECT_THAT(Extract(kOne, 2, 0), ::testing::IsEmpty());
  152. EXPECT_THAT(Extract(kOneTwoThree, 0, 4), ::testing::IsEmpty());
  153. EXPECT_THAT(Extract(kOneTwoThree, 1, 3), ::testing::IsEmpty());
  154. EXPECT_THAT(Extract(kOneTwoThree, 2, 2), ::testing::IsEmpty());
  155. EXPECT_THAT(Extract(kOneTwoThree, 3, 1), ::testing::IsEmpty());
  156. EXPECT_THAT(Extract(kOneTwoThree, 4, 0), ::testing::IsEmpty());
  157. }
  158. TEST(U2fParsingUtils, ExtractSuffixEmpty) {
  159. const std::vector<uint8_t> empty;
  160. EXPECT_THAT(ExtractSuffix(empty, 0), ::testing::IsEmpty());
  161. EXPECT_THAT(ExtractSuffix(kOne, 1), ::testing::IsEmpty());
  162. EXPECT_THAT(ExtractSuffix(kOneTwoThree, 3), ::testing::IsEmpty());
  163. }
  164. TEST(U2fParsingUtils, ExtractSuffixInBounds) {
  165. EXPECT_THAT(ExtractSuffix(kOne, 0), ::testing::ElementsAreArray(kOne));
  166. EXPECT_THAT(ExtractSuffix(kOneTwoThree, 1),
  167. ::testing::ElementsAreArray(kTwoThree));
  168. EXPECT_THAT(ExtractSuffix(kOneTwoThree, 2),
  169. ::testing::ElementsAreArray(kThree));
  170. }
  171. TEST(U2fParsingUtils, ExtractSuffixOutOfBounds) {
  172. const std::vector<uint8_t> empty;
  173. EXPECT_THAT(ExtractSuffix(empty, 1), ::testing::IsEmpty());
  174. EXPECT_THAT(ExtractSuffix(kOne, 2), ::testing::IsEmpty());
  175. EXPECT_THAT(ExtractSuffix(kOneTwoThree, 4), ::testing::IsEmpty());
  176. }
  177. TEST(U2fParsingUtils, ExtractArray) {
  178. const std::vector<uint8_t> empty;
  179. std::array<uint8_t, 0> array_empty;
  180. EXPECT_TRUE(ExtractArray(empty, 0, &array_empty));
  181. std::array<uint8_t, 2> array_two_three;
  182. EXPECT_TRUE(ExtractArray(kTwoThree, 0, &array_two_three));
  183. EXPECT_THAT(array_two_three, ::testing::ElementsAreArray(kTwoThree));
  184. EXPECT_FALSE(ExtractArray(kOneTwoThree, 2, &array_two_three));
  185. std::array<uint8_t, 1> array_three;
  186. EXPECT_TRUE(ExtractArray(kOneTwoThree, 2, &array_three));
  187. EXPECT_THAT(array_three, ::testing::ElementsAreArray(kThree));
  188. }
  189. TEST(U2fParsingUtils, SplitSpan) {
  190. std::vector<uint8_t> empty;
  191. EXPECT_THAT(SplitSpan(empty, 1), ::testing::IsEmpty());
  192. EXPECT_THAT(SplitSpan(empty, 2), ::testing::IsEmpty());
  193. EXPECT_THAT(SplitSpan(empty, 3), ::testing::IsEmpty());
  194. EXPECT_THAT(SplitSpan(kOne, 1),
  195. ::testing::ElementsAre(::testing::ElementsAreArray(kOne)));
  196. EXPECT_THAT(SplitSpan(kOne, 2),
  197. ::testing::ElementsAre(::testing::ElementsAreArray(kOne)));
  198. EXPECT_THAT(SplitSpan(kOne, 3),
  199. ::testing::ElementsAre(::testing::ElementsAreArray(kOne)));
  200. EXPECT_THAT(SplitSpan(kOneTwo, 1),
  201. ::testing::ElementsAre(::testing::ElementsAreArray(kOne),
  202. ::testing::ElementsAreArray(kTwo)));
  203. EXPECT_THAT(SplitSpan(kOneTwo, 2),
  204. ::testing::ElementsAre(::testing::ElementsAreArray(kOneTwo)));
  205. EXPECT_THAT(SplitSpan(kOneTwo, 3),
  206. ::testing::ElementsAre(::testing::ElementsAreArray(kOneTwo)));
  207. EXPECT_THAT(SplitSpan(kOneTwoThree, 1),
  208. ::testing::ElementsAre(::testing::ElementsAreArray(kOne),
  209. ::testing::ElementsAreArray(kTwo),
  210. ::testing::ElementsAreArray(kThree)));
  211. EXPECT_THAT(SplitSpan(kOneTwoThree, 2),
  212. ::testing::ElementsAre(::testing::ElementsAreArray(kOneTwo),
  213. ::testing::ElementsAreArray(kThree)));
  214. EXPECT_THAT(
  215. SplitSpan(kOneTwoThree, 3),
  216. ::testing::ElementsAre(::testing::ElementsAreArray(kOneTwoThree)));
  217. EXPECT_THAT(
  218. SplitSpan(kOneTwoThree, 4),
  219. ::testing::ElementsAre(::testing::ElementsAreArray(kOneTwoThree)));
  220. EXPECT_THAT(
  221. SplitSpan(kOneTwoThree, 5),
  222. ::testing::ElementsAre(::testing::ElementsAreArray(kOneTwoThree)));
  223. EXPECT_THAT(
  224. SplitSpan(kOneTwoThree, 6),
  225. ::testing::ElementsAre(::testing::ElementsAreArray(kOneTwoThree)));
  226. }
  227. TEST(U2fParsingUtils, CreateSHA256Hash) {
  228. EXPECT_THAT(CreateSHA256Hash("acme.com"),
  229. ::testing::ElementsAreArray(test_data::kApplicationParameter));
  230. }
  231. TEST(U2fParsingUtils, ConvertSpanToStringPiece) {
  232. constexpr uint8_t kTestAsciiAbcd[] = {'a', 'b', 'c', 'd'};
  233. EXPECT_EQ("abcd", ConvertToStringPiece(kTestAsciiAbcd));
  234. }
  235. } // namespace fido_parsing_utils
  236. } // namespace device