fido_hid_message_unittest.cc 8.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231
  1. // Copyright 2017 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/hid/fido_hid_message.h"
  5. #include "base/memory/ptr_util.h"
  6. #include "base/numerics/safe_conversions.h"
  7. #include "device/fido/fido_constants.h"
  8. #include "device/fido/hid/fido_hid_packet.h"
  9. #include "testing/gmock/include/gmock/gmock.h"
  10. #include "testing/gtest/include/gtest/gtest.h"
  11. namespace device {
  12. static const size_t kDefaultInitDataSize =
  13. kHidMaxPacketSize - kHidInitPacketHeaderSize;
  14. static const size_t kDefaultContinuationDataSize =
  15. kHidMaxPacketSize - kHidContinuationPacketHeaderSize;
  16. /*
  17. * U2f Init Packets are of the format:
  18. * Byte 0: 0
  19. * Byte 1-4: Channel ID
  20. * Byte 5: Command byte
  21. * Byte 6-7: Big Endian size of data
  22. * Byte 8-n: Data block
  23. *
  24. * Remaining buffer is padded with 0
  25. */
  26. TEST(FidoHidMessageTest, TestPacketData) {
  27. uint32_t channel_id = 0xF5060708;
  28. std::vector<uint8_t> data{10, 11};
  29. FidoHidDeviceCommand cmd = FidoHidDeviceCommand::kWink;
  30. auto init_packet =
  31. std::make_unique<FidoHidInitPacket>(channel_id, cmd, data, data.size());
  32. size_t index = 0;
  33. std::vector<uint8_t> serialized = init_packet->GetSerializedData();
  34. EXPECT_EQ((channel_id >> 24) & 0xff, serialized[index++]);
  35. EXPECT_EQ((channel_id >> 16) & 0xff, serialized[index++]);
  36. EXPECT_EQ((channel_id >> 8) & 0xff, serialized[index++]);
  37. EXPECT_EQ(channel_id & 0xff, serialized[index++]);
  38. EXPECT_EQ(base::strict_cast<uint8_t>(cmd), serialized[index++] & 0x7f);
  39. EXPECT_EQ(data.size() >> 8, serialized[index++]);
  40. EXPECT_EQ(data.size() & 0xff, serialized[index++]);
  41. EXPECT_EQ(data[0], serialized[index++]);
  42. EXPECT_EQ(data[1], serialized[index++]);
  43. for (; index < serialized.size(); index++)
  44. EXPECT_EQ(0, serialized[index]) << "mismatch at index " << index;
  45. }
  46. TEST(FidoHidMessageTest, TestPacketConstructors) {
  47. uint32_t channel_id = 0x05060708;
  48. std::vector<uint8_t> data{10, 11};
  49. FidoHidDeviceCommand cmd = FidoHidDeviceCommand::kWink;
  50. auto orig_packet =
  51. std::make_unique<FidoHidInitPacket>(channel_id, cmd, data, data.size());
  52. size_t payload_length = static_cast<size_t>(orig_packet->payload_length());
  53. std::vector<uint8_t> orig_data = orig_packet->GetSerializedData();
  54. auto reconstructed_packet =
  55. FidoHidInitPacket::CreateFromSerializedData(orig_data, &payload_length);
  56. EXPECT_EQ(orig_packet->command(), reconstructed_packet->command());
  57. EXPECT_EQ(orig_packet->payload_length(),
  58. reconstructed_packet->payload_length());
  59. EXPECT_THAT(orig_packet->GetPacketPayload(),
  60. ::testing::ContainerEq(reconstructed_packet->GetPacketPayload()));
  61. EXPECT_EQ(channel_id, reconstructed_packet->channel_id());
  62. ASSERT_EQ(orig_packet->GetSerializedData().size(),
  63. reconstructed_packet->GetSerializedData().size());
  64. for (size_t index = 0; index < orig_packet->GetSerializedData().size();
  65. ++index) {
  66. EXPECT_EQ(orig_packet->GetSerializedData()[index],
  67. reconstructed_packet->GetSerializedData()[index])
  68. << "mismatch at index " << index;
  69. }
  70. }
  71. TEST(FidoHidMessageTest, TestMaxLengthPacketConstructors) {
  72. uint32_t channel_id = 0xAAABACAD;
  73. std::vector<uint8_t> data;
  74. for (size_t i = 0; i < kHidMaxMessageSize; ++i)
  75. data.push_back(static_cast<uint8_t>(i % 0xff));
  76. for (size_t report_size = kHidInitPacketHeaderSize + 1;
  77. report_size <= kHidMaxPacketSize; report_size++) {
  78. auto orig_msg = FidoHidMessage::Create(
  79. channel_id, FidoHidDeviceCommand::kMsg, report_size, data);
  80. ASSERT_TRUE(orig_msg);
  81. const auto& original_msg_packets = orig_msg->GetPacketsForTesting();
  82. auto it = original_msg_packets.begin();
  83. auto msg_data = (*it)->GetSerializedData();
  84. auto new_msg = FidoHidMessage::CreateFromSerializedData(msg_data);
  85. it++;
  86. for (; it != original_msg_packets.end(); ++it) {
  87. msg_data = (*it)->GetSerializedData();
  88. new_msg->AddContinuationPacket(msg_data);
  89. }
  90. EXPECT_EQ(new_msg->NumPackets(), orig_msg->NumPackets());
  91. auto orig_it = original_msg_packets.begin();
  92. const auto& new_msg_packets = new_msg->GetPacketsForTesting();
  93. auto new_msg_it = new_msg_packets.begin();
  94. for (; orig_it != original_msg_packets.end() &&
  95. new_msg_it != new_msg_packets.end();
  96. ++orig_it, ++new_msg_it) {
  97. EXPECT_THAT((*orig_it)->GetPacketPayload(),
  98. ::testing::ContainerEq((*new_msg_it)->GetPacketPayload()));
  99. EXPECT_EQ((*orig_it)->channel_id(), (*new_msg_it)->channel_id());
  100. ASSERT_EQ((*orig_it)->GetSerializedData().size(),
  101. (*new_msg_it)->GetSerializedData().size());
  102. for (size_t index = 0; index < (*orig_it)->GetSerializedData().size();
  103. ++index) {
  104. EXPECT_EQ((*orig_it)->GetSerializedData()[index],
  105. (*new_msg_it)->GetSerializedData()[index])
  106. << "mismatch at index " << index;
  107. }
  108. }
  109. EXPECT_TRUE(orig_it == original_msg_packets.end());
  110. EXPECT_TRUE(new_msg_it == new_msg_packets.end());
  111. }
  112. }
  113. TEST(FidoHidMessageTest, TestMessagePartitoning) {
  114. uint32_t channel_id = 0x01010203;
  115. std::vector<uint8_t> data(kDefaultInitDataSize + 1);
  116. auto two_packet_message = FidoHidMessage::Create(
  117. channel_id, FidoHidDeviceCommand::kPing, kHidMaxPacketSize, data);
  118. ASSERT_TRUE(two_packet_message);
  119. EXPECT_EQ(2U, two_packet_message->NumPackets());
  120. data.resize(kDefaultInitDataSize);
  121. auto one_packet_message = FidoHidMessage::Create(
  122. channel_id, FidoHidDeviceCommand::kPing, kHidMaxPacketSize, data);
  123. ASSERT_TRUE(one_packet_message);
  124. EXPECT_EQ(1U, one_packet_message->NumPackets());
  125. data.resize(kDefaultInitDataSize + kDefaultContinuationDataSize + 1);
  126. auto three_packet_message = FidoHidMessage::Create(
  127. channel_id, FidoHidDeviceCommand::kPing, kHidMaxPacketSize, data);
  128. ASSERT_TRUE(three_packet_message);
  129. EXPECT_EQ(3U, three_packet_message->NumPackets());
  130. // With the minimal report size, only a single byte of data will fit in an
  131. // init message, followed by three bytes in each continuation message.
  132. data.resize(1 + 3 + 3);
  133. auto three_small_messages =
  134. FidoHidMessage::Create(channel_id, FidoHidDeviceCommand::kPing,
  135. kHidInitPacketHeaderSize + 1, data);
  136. ASSERT_TRUE(three_small_messages);
  137. EXPECT_EQ(3U, three_small_messages->NumPackets());
  138. }
  139. TEST(FidoHidMessageTest, TooLarge) {
  140. std::vector<uint8_t> data;
  141. #if DCHECK_IS_ON()
  142. #define EXPECT_SIZE_FAILURE(x) EXPECT_DEATH_IF_SUPPORTED(x, "")
  143. #else
  144. #define EXPECT_SIZE_FAILURE(x) EXPECT_FALSE(x.has_value())
  145. #endif
  146. // kHidInitPacketHeaderSize is too small a report size to be valid.
  147. EXPECT_SIZE_FAILURE(FidoHidMessage::Create(kHidBroadcastChannel,
  148. FidoHidDeviceCommand::kPing,
  149. kHidInitPacketHeaderSize, data));
  150. // kHidMaxPacketSize + 1 is too large a report size.
  151. EXPECT_SIZE_FAILURE(FidoHidMessage::Create(kHidBroadcastChannel,
  152. FidoHidDeviceCommand::kPing,
  153. kHidMaxPacketSize + 1, data));
  154. #undef EXPECT_SIZE_FAILURE
  155. }
  156. TEST(FidoHidMessageTest, TestMaxSize) {
  157. uint32_t channel_id = 0x00010203;
  158. std::vector<uint8_t> data(kHidMaxMessageSize + 1);
  159. auto oversize_message = FidoHidMessage::Create(
  160. channel_id, FidoHidDeviceCommand::kPing, kHidMaxPacketSize, data);
  161. EXPECT_FALSE(oversize_message);
  162. }
  163. TEST(FidoHidMessageTest, TestDeconstruct) {
  164. uint32_t channel_id = 0x0A0B0C0D;
  165. std::vector<uint8_t> data(kHidMaxMessageSize, 0x7F);
  166. auto filled_message = FidoHidMessage::Create(
  167. channel_id, FidoHidDeviceCommand::kPing, kHidMaxPacketSize, data);
  168. ASSERT_TRUE(filled_message);
  169. EXPECT_THAT(data,
  170. ::testing::ContainerEq(filled_message->GetMessagePayload()));
  171. }
  172. TEST(FidoHidMessageTest, TestDeserialize) {
  173. uint32_t channel_id = 0x0A0B0C0D;
  174. std::vector<uint8_t> data(kHidMaxMessageSize);
  175. auto orig_message = FidoHidMessage::Create(
  176. channel_id, FidoHidDeviceCommand::kPing, kHidMaxPacketSize, data);
  177. ASSERT_TRUE(orig_message);
  178. base::circular_deque<std::vector<uint8_t>> orig_list;
  179. auto buf = orig_message->PopNextPacket();
  180. orig_list.push_back(buf);
  181. auto new_message = FidoHidMessage::CreateFromSerializedData(buf);
  182. while (!new_message->MessageComplete()) {
  183. buf = orig_message->PopNextPacket();
  184. orig_list.push_back(buf);
  185. new_message->AddContinuationPacket(buf);
  186. }
  187. while (!(buf = new_message->PopNextPacket()).empty()) {
  188. EXPECT_EQ(buf, orig_list.front());
  189. orig_list.pop_front();
  190. }
  191. }
  192. } // namespace device