OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "device/u2f/u2f_message.h" | 5 #include "device/u2f/u2f_message.h" |
| 6 #include "base/memory/ptr_util.h" |
6 #include "net/base/io_buffer.h" | 7 #include "net/base/io_buffer.h" |
7 #include "testing/gmock/include/gmock/gmock.h" | 8 #include "testing/gmock/include/gmock/gmock.h" |
8 #include "testing/gtest/include/gtest/gtest.h" | 9 #include "testing/gtest/include/gtest/gtest.h" |
9 | 10 |
10 namespace device { | 11 namespace device { |
11 | 12 |
12 class U2fMessageTest : public testing::Test {}; | 13 class U2fMessageTest : public testing::Test {}; |
13 | 14 |
14 // Packets should be 64 bytes + 1 report ID byte | 15 // Packets should be 64 bytes + 1 report ID byte |
15 TEST_F(U2fMessageTest, TestPacketSize) { | 16 TEST_F(U2fMessageTest, TestPacketSize) { |
16 uint32_t channel_id = 0x05060708; | 17 uint32_t channel_id = 0x05060708; |
17 std::vector<uint8_t> data; | 18 std::vector<uint8_t> data; |
18 | 19 |
19 scoped_refptr<U2fPacket> init_packet( | 20 auto init_packet = |
20 new U2fInitPacket(channel_id, 0, data, data.size())); | 21 base::MakeUnique<U2fInitPacket>(channel_id, 0, data, data.size()); |
21 EXPECT_EQ(65, init_packet->GetSerializedBuffer()->size()); | 22 EXPECT_EQ(65, init_packet->GetSerializedBuffer()->size()); |
22 | 23 |
23 scoped_refptr<U2fPacket> continuation_packet( | 24 auto continuation_packet = |
24 new U2fContinuationPacket(channel_id, 0, data)); | 25 base::MakeUnique<U2fContinuationPacket>(channel_id, 0, data); |
25 EXPECT_EQ(65, continuation_packet->GetSerializedBuffer()->size()); | 26 EXPECT_EQ(65, continuation_packet->GetSerializedBuffer()->size()); |
26 } | 27 } |
27 | 28 |
28 /* | 29 /* |
29 * U2f Init Packets are of the format: | 30 * U2f Init Packets are of the format: |
30 * Byte 0: 0 | 31 * Byte 0: 0 |
31 * Byte 1-4: Channel ID | 32 * Byte 1-4: Channel ID |
32 * Byte 5: Command byte | 33 * Byte 5: Command byte |
33 * Byte 6-7: Big Endian size of data | 34 * Byte 6-7: Big Endian size of data |
34 * Byte 8-n: Data block | 35 * Byte 8-n: Data block |
35 * | 36 * |
36 * Remaining buffer is padded with 0 | 37 * Remaining buffer is padded with 0 |
37 */ | 38 */ |
38 TEST_F(U2fMessageTest, TestPacketData) { | 39 TEST_F(U2fMessageTest, TestPacketData) { |
39 uint32_t channel_id = 0xF5060708; | 40 uint32_t channel_id = 0xF5060708; |
40 std::vector<uint8_t> data{10, 11}; | 41 std::vector<uint8_t> data{10, 11}; |
41 uint8_t cmd = static_cast<uint8_t>(U2fMessage::Type::CMD_WINK); | 42 uint8_t cmd = static_cast<uint8_t>(U2fMessage::Type::CMD_WINK); |
42 scoped_refptr<U2fPacket> init_packet( | 43 auto init_packet = |
43 new U2fInitPacket(channel_id, cmd, data, data.size())); | 44 base::MakeUnique<U2fInitPacket>(channel_id, cmd, data, data.size()); |
44 int index = 0; | 45 int index = 0; |
45 | 46 |
46 EXPECT_EQ(0, init_packet->GetSerializedBuffer()->data()[index++]); | 47 EXPECT_EQ(0, init_packet->GetSerializedBuffer()->data()[index++]); |
47 EXPECT_EQ((channel_id >> 24) & 0xff, | 48 EXPECT_EQ((channel_id >> 24) & 0xff, |
48 static_cast<uint8_t>( | 49 static_cast<uint8_t>( |
49 init_packet->GetSerializedBuffer()->data()[index++])); | 50 init_packet->GetSerializedBuffer()->data()[index++])); |
50 EXPECT_EQ((channel_id >> 16) & 0xff, | 51 EXPECT_EQ((channel_id >> 16) & 0xff, |
51 static_cast<uint8_t>( | 52 static_cast<uint8_t>( |
52 init_packet->GetSerializedBuffer()->data()[index++])); | 53 init_packet->GetSerializedBuffer()->data()[index++])); |
53 EXPECT_EQ((channel_id >> 8) & 0xff, | 54 EXPECT_EQ((channel_id >> 8) & 0xff, |
(...skipping 16 matching lines...) Expand all Loading... |
70 for (; index < init_packet->GetSerializedBuffer()->size(); index++) { | 71 for (; index < init_packet->GetSerializedBuffer()->size(); index++) { |
71 EXPECT_EQ(0, init_packet->GetSerializedBuffer()->data()[index]) | 72 EXPECT_EQ(0, init_packet->GetSerializedBuffer()->data()[index]) |
72 << "mismatch at index " << index; | 73 << "mismatch at index " << index; |
73 } | 74 } |
74 } | 75 } |
75 | 76 |
76 TEST_F(U2fMessageTest, TestPacketConstructors) { | 77 TEST_F(U2fMessageTest, TestPacketConstructors) { |
77 uint32_t channel_id = 0x05060708; | 78 uint32_t channel_id = 0x05060708; |
78 std::vector<uint8_t> data{10, 11}; | 79 std::vector<uint8_t> data{10, 11}; |
79 uint8_t cmd = static_cast<uint8_t>(U2fMessage::Type::CMD_WINK); | 80 uint8_t cmd = static_cast<uint8_t>(U2fMessage::Type::CMD_WINK); |
80 scoped_refptr<U2fInitPacket> orig_packet( | 81 auto orig_packet = |
81 new U2fInitPacket(channel_id, cmd, data, data.size())); | 82 base::MakeUnique<U2fInitPacket>(channel_id, cmd, data, data.size()); |
82 | 83 |
83 size_t payload_length = static_cast<size_t>(orig_packet->payload_length()); | 84 size_t payload_length = static_cast<size_t>(orig_packet->payload_length()); |
84 scoped_refptr<U2fInitPacket> reconstructed_packet = | 85 std::unique_ptr<U2fInitPacket> reconstructed_packet = |
85 U2fInitPacket::CreateFromSerializedData( | 86 U2fInitPacket::CreateFromSerializedData( |
86 orig_packet->GetSerializedBuffer(), &payload_length); | 87 orig_packet->GetSerializedBuffer(), &payload_length); |
87 EXPECT_EQ(orig_packet->command(), reconstructed_packet->command()); | 88 EXPECT_EQ(orig_packet->command(), reconstructed_packet->command()); |
88 EXPECT_EQ(orig_packet->payload_length(), | 89 EXPECT_EQ(orig_packet->payload_length(), |
89 reconstructed_packet->payload_length()); | 90 reconstructed_packet->payload_length()); |
90 EXPECT_THAT(orig_packet->GetPacketPayload(), | 91 EXPECT_THAT(orig_packet->GetPacketPayload(), |
91 testing::ContainerEq(reconstructed_packet->GetPacketPayload())); | 92 testing::ContainerEq(reconstructed_packet->GetPacketPayload())); |
92 | 93 |
93 EXPECT_EQ(channel_id, reconstructed_packet->channel_id()); | 94 EXPECT_EQ(channel_id, reconstructed_packet->channel_id()); |
94 | 95 |
95 ASSERT_EQ(orig_packet->GetSerializedBuffer()->size(), | 96 ASSERT_EQ(orig_packet->GetSerializedBuffer()->size(), |
96 reconstructed_packet->GetSerializedBuffer()->size()); | 97 reconstructed_packet->GetSerializedBuffer()->size()); |
97 for (size_t i = 0; | 98 for (size_t i = 0; |
98 i < static_cast<size_t>(orig_packet->GetSerializedBuffer()->size()); | 99 i < static_cast<size_t>(orig_packet->GetSerializedBuffer()->size()); |
99 ++i) { | 100 ++i) { |
100 EXPECT_EQ(orig_packet->GetSerializedBuffer()->data()[i], | 101 EXPECT_EQ(orig_packet->GetSerializedBuffer()->data()[i], |
101 reconstructed_packet->GetSerializedBuffer()->data()[i]); | 102 reconstructed_packet->GetSerializedBuffer()->data()[i]); |
102 } | 103 } |
103 } | 104 } |
104 | 105 |
105 TEST_F(U2fMessageTest, TestMaxLengthPacketConstructors) { | 106 TEST_F(U2fMessageTest, TestMaxLengthPacketConstructors) { |
106 uint32_t channel_id = 0xAAABACAD; | 107 uint32_t channel_id = 0xAAABACAD; |
107 std::vector<uint8_t> data; | 108 std::vector<uint8_t> data; |
108 for (size_t i = 0; i < U2fMessage::kMaxMessageSize; ++i) | 109 for (size_t i = 0; i < U2fMessage::kMaxMessageSize; ++i) |
109 data.push_back(static_cast<uint8_t>(i % 0xff)); | 110 data.push_back(static_cast<uint8_t>(i % 0xff)); |
110 | 111 |
111 U2fMessage::Type cmd = U2fMessage::Type::CMD_MSG; | 112 U2fMessage::Type cmd = U2fMessage::Type::CMD_MSG; |
112 scoped_refptr<U2fMessage> orig_msg = | 113 std::unique_ptr<U2fMessage> orig_msg = |
113 U2fMessage::Create(channel_id, cmd, data); | 114 U2fMessage::Create(channel_id, cmd, data); |
114 auto it = orig_msg->begin(); | 115 auto it = orig_msg->begin(); |
115 scoped_refptr<U2fMessage> new_msg = | 116 std::unique_ptr<U2fMessage> new_msg = |
116 U2fMessage::CreateFromSerializedData((*it)->GetSerializedBuffer()); | 117 U2fMessage::CreateFromSerializedData((*it)->GetSerializedBuffer()); |
117 it++; | 118 it++; |
118 | 119 |
119 for (; it != orig_msg->end(); ++it) | 120 for (; it != orig_msg->end(); ++it) |
120 new_msg->AddContinuationPacket((*it)->GetSerializedBuffer()); | 121 new_msg->AddContinuationPacket((*it)->GetSerializedBuffer()); |
121 | 122 |
122 auto orig_it = orig_msg->begin(); | 123 auto orig_it = orig_msg->begin(); |
123 auto new_it = new_msg->begin(); | 124 auto new_it = new_msg->begin(); |
124 | 125 |
125 for (; orig_it != orig_msg->end() && new_it != new_msg->end(); | 126 for (; orig_it != orig_msg->end() && new_it != new_msg->end(); |
(...skipping 10 matching lines...) Expand all Loading... |
136 ++i) { | 137 ++i) { |
137 EXPECT_EQ((*orig_it)->GetSerializedBuffer()->data()[i], | 138 EXPECT_EQ((*orig_it)->GetSerializedBuffer()->data()[i], |
138 (*new_it)->GetSerializedBuffer()->data()[i]); | 139 (*new_it)->GetSerializedBuffer()->data()[i]); |
139 } | 140 } |
140 } | 141 } |
141 } | 142 } |
142 | 143 |
143 TEST_F(U2fMessageTest, TestMessagePartitoning) { | 144 TEST_F(U2fMessageTest, TestMessagePartitoning) { |
144 uint32_t channel_id = 0x01010203; | 145 uint32_t channel_id = 0x01010203; |
145 std::vector<uint8_t> data(U2fMessage::kInitPacketDataSize + 1); | 146 std::vector<uint8_t> data(U2fMessage::kInitPacketDataSize + 1); |
146 scoped_refptr<U2fMessage> two_packet_message = | 147 std::unique_ptr<U2fMessage> two_packet_message = |
147 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); | 148 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); |
148 EXPECT_EQ(2U, two_packet_message->NumPackets()); | 149 EXPECT_EQ(2U, two_packet_message->NumPackets()); |
149 | 150 |
150 data.resize(U2fMessage::kInitPacketDataSize); | 151 data.resize(U2fMessage::kInitPacketDataSize); |
151 scoped_refptr<U2fMessage> one_packet_message = | 152 std::unique_ptr<U2fMessage> one_packet_message = |
152 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); | 153 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); |
153 EXPECT_EQ(1U, one_packet_message->NumPackets()); | 154 EXPECT_EQ(1U, one_packet_message->NumPackets()); |
154 | 155 |
155 data.resize(U2fMessage::kInitPacketDataSize + | 156 data.resize(U2fMessage::kInitPacketDataSize + |
156 U2fMessage::kContinuationPacketDataSize + 1); | 157 U2fMessage::kContinuationPacketDataSize + 1); |
157 scoped_refptr<U2fMessage> three_packet_message = | 158 std::unique_ptr<U2fMessage> three_packet_message = |
158 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); | 159 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); |
159 EXPECT_EQ(3U, three_packet_message->NumPackets()); | 160 EXPECT_EQ(3U, three_packet_message->NumPackets()); |
160 } | 161 } |
161 | 162 |
162 TEST_F(U2fMessageTest, TestMaxSize) { | 163 TEST_F(U2fMessageTest, TestMaxSize) { |
163 uint32_t channel_id = 0x00010203; | 164 uint32_t channel_id = 0x00010203; |
164 std::vector<uint8_t> data(U2fMessage::kMaxMessageSize + 1); | 165 std::vector<uint8_t> data(U2fMessage::kMaxMessageSize + 1); |
165 scoped_refptr<U2fMessage> oversize_message = | 166 std::unique_ptr<U2fMessage> oversize_message = |
166 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); | 167 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); |
167 EXPECT_EQ(nullptr, oversize_message); | 168 EXPECT_EQ(nullptr, oversize_message); |
168 } | 169 } |
169 | 170 |
170 TEST_F(U2fMessageTest, TestDeconstruct) { | 171 TEST_F(U2fMessageTest, TestDeconstruct) { |
171 uint32_t channel_id = 0x0A0B0C0D; | 172 uint32_t channel_id = 0x0A0B0C0D; |
172 std::vector<uint8_t> data(U2fMessage::kMaxMessageSize, 0x7F); | 173 std::vector<uint8_t> data(U2fMessage::kMaxMessageSize, 0x7F); |
173 scoped_refptr<U2fMessage> filled_message = | 174 std::unique_ptr<U2fMessage> filled_message = |
174 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); | 175 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); |
175 | 176 |
176 EXPECT_THAT(data, testing::ContainerEq(filled_message->GetMessagePayload())); | 177 EXPECT_THAT(data, testing::ContainerEq(filled_message->GetMessagePayload())); |
177 } | 178 } |
178 | 179 |
179 TEST_F(U2fMessageTest, TestDeserialize) { | 180 TEST_F(U2fMessageTest, TestDeserialize) { |
180 uint32_t channel_id = 0x0A0B0C0D; | 181 uint32_t channel_id = 0x0A0B0C0D; |
181 std::vector<uint8_t> data(U2fMessage::kMaxMessageSize); | 182 std::vector<uint8_t> data(U2fMessage::kMaxMessageSize); |
182 | 183 |
183 scoped_refptr<U2fMessage> orig_message = | 184 std::unique_ptr<U2fMessage> orig_message = |
184 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); | 185 U2fMessage::Create(channel_id, U2fMessage::Type::CMD_PING, data); |
185 std::list<scoped_refptr<net::IOBufferWithSize>> orig_list; | 186 std::list<scoped_refptr<net::IOBufferWithSize>> orig_list; |
186 scoped_refptr<net::IOBufferWithSize> buf = orig_message->PopNextPacket(); | 187 scoped_refptr<net::IOBufferWithSize> buf = orig_message->PopNextPacket(); |
187 orig_list.push_back(buf); | 188 orig_list.push_back(buf); |
188 | 189 |
189 scoped_refptr<U2fMessage> new_message = | 190 std::unique_ptr<U2fMessage> new_message = |
190 U2fMessage::CreateFromSerializedData(buf); | 191 U2fMessage::CreateFromSerializedData(buf); |
191 while (!new_message->MessageComplete()) { | 192 while (!new_message->MessageComplete()) { |
192 buf = orig_message->PopNextPacket(); | 193 buf = orig_message->PopNextPacket(); |
193 orig_list.push_back(buf); | 194 orig_list.push_back(buf); |
194 new_message->AddContinuationPacket(buf); | 195 new_message->AddContinuationPacket(buf); |
195 } | 196 } |
196 | 197 |
197 while ((buf = new_message->PopNextPacket())) { | 198 while ((buf = new_message->PopNextPacket())) { |
198 ASSERT_EQ(buf->size(), orig_list.front()->size()); | 199 ASSERT_EQ(buf->size(), orig_list.front()->size()); |
199 EXPECT_EQ(0, memcmp(buf->data(), orig_list.front()->data(), buf->size())); | 200 EXPECT_EQ(0, memcmp(buf->data(), orig_list.front()->data(), buf->size())); |
200 orig_list.pop_front(); | 201 orig_list.pop_front(); |
201 } | 202 } |
202 } | 203 } |
203 } // namespace device | 204 } // namespace device |
OLD | NEW |