OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2012 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 | |
5 #include <map> | |
6 #include <vector> | |
7 | |
8 #include "base/logging.h" | |
9 #include "base/memory/scoped_ptr.h" | |
10 #include "net/quic/crypto/crypto_framer.h" | |
11 #include "net/quic/crypto/crypto_protocol.h" | |
12 #include "net/quic/test_tools/quic_test_utils.h" | |
13 | |
14 using base::StringPiece; | |
15 using std::map; | |
16 using std::string; | |
17 using std::vector; | |
18 | |
19 namespace net { | |
20 | |
21 namespace { | |
22 | |
23 char* AsChars(unsigned char* data) { | |
24 return reinterpret_cast<char*>(data); | |
25 } | |
26 | |
27 } // namespace | |
28 | |
29 namespace test { | |
30 | |
31 class TestCryptoVisitor : public ::net::CryptoFramerVisitorInterface { | |
32 public: | |
33 TestCryptoVisitor() | |
34 : error_count_(0) { | |
35 } | |
36 | |
37 ~TestCryptoVisitor() {} | |
38 | |
39 virtual void OnError(CryptoFramer* f) { | |
40 LOG(INFO) << "CryptoFramer Error: " << f->error(); | |
41 error_count_++; | |
42 } | |
43 | |
44 virtual void OnHandshakeMessage(const CryptoHandshakeMessage& message) { | |
45 message_tags_.push_back(message.tag); | |
46 message_maps_.push_back(map<CryptoTag, string>()); | |
47 CryptoTagValueMap::const_iterator it = message.tag_value_map.begin(); | |
48 while (it != message.tag_value_map.end()) { | |
49 message_maps_.back()[it->first] = it->second.as_string(); | |
50 ++it; | |
51 } | |
52 } | |
53 | |
54 CryptoFramer framer_; | |
55 | |
56 // Counters from the visitor callbacks. | |
57 int error_count_; | |
58 | |
59 vector<CryptoTag> message_tags_; | |
60 vector<map<CryptoTag, string> > message_maps_; | |
61 }; | |
62 | |
63 } // namespace test | |
64 | |
65 TEST(CryptoFramerTest, ConstructHandshakeMessage) { | |
66 CryptoHandshakeMessage message; | |
67 message.tag = 0xFFAA7733; | |
68 message.tag_value_map[0x12345678] = "abcdef"; | |
69 message.tag_value_map[0x12345679] = "ghijk"; | |
70 message.tag_value_map[0x1234567A] = "lmnopqr"; | |
71 | |
72 unsigned char packet[] = { | |
73 // tag | |
74 0x33, 0x77, 0xAA, 0xFF, | |
75 // num entires | |
76 0x03, 0x00, | |
77 // tag 1 | |
78 0x78, 0x56, 0x34, 0x12, | |
79 // tag 2 | |
80 0x79, 0x56, 0x34, 0x12, | |
81 // tag 3 | |
82 0x7A, 0x56, 0x34, 0x12, | |
83 // len 1 | |
84 0x06, 0x00, | |
85 // len 2 | |
86 0x05, 0x00, | |
87 // len 3 | |
88 0x07, 0x00, | |
89 // padding | |
90 0xAB, 0xAB, | |
91 // value 1 | |
92 'a', 'b', 'c', 'd', | |
93 'e', 'f', | |
94 // value 2 | |
95 'g', 'h', 'i', 'j', | |
96 'k', | |
97 // value 3 | |
98 'l', 'm', 'n', 'o', | |
99 'p', 'q', 'r', | |
100 }; | |
101 | |
102 CryptoFramer framer; | |
103 QuicData* data; | |
104 EXPECT_TRUE(framer.ConstructHandshakeMessage(message, &data)); | |
105 | |
106 test::CompareCharArraysWithHexError("constructed packet", | |
107 data->data(), data->length(), | |
108 AsChars(packet), arraysize(packet)); | |
109 | |
110 delete data; | |
111 } | |
112 | |
113 TEST(CryptoFramerTest, ConstructHandshakeMessageWithTwoKeys) { | |
114 CryptoHandshakeMessage message; | |
115 message.tag = 0xFFAA7733; | |
116 message.tag_value_map[0x12345678] = "abcdef"; | |
117 message.tag_value_map[0x12345679] = "ghijk"; | |
118 | |
119 unsigned char packet[] = { | |
120 // tag | |
121 0x33, 0x77, 0xAA, 0xFF, | |
122 // num entires | |
123 0x02, 0x00, | |
124 // tag 1 | |
125 0x78, 0x56, 0x34, 0x12, | |
126 // tag 2 | |
127 0x79, 0x56, 0x34, 0x12, | |
128 // len 1 | |
129 0x06, 0x00, | |
130 // len 2 | |
131 0x05, 0x00, | |
132 // value 1 | |
133 'a', 'b', 'c', 'd', | |
134 'e', 'f', | |
135 // value 2 | |
136 'g', 'h', 'i', 'j', | |
137 'k', | |
138 }; | |
139 | |
140 CryptoFramer framer; | |
141 QuicData* data; | |
142 EXPECT_TRUE(framer.ConstructHandshakeMessage(message, &data)); | |
143 | |
144 test::CompareCharArraysWithHexError("constructed packet", | |
145 data->data(), data->length(), | |
146 AsChars(packet), arraysize(packet)); | |
147 | |
148 delete data; | |
149 } | |
150 | |
151 TEST(CryptoFramerTest, ConstructHandshakeMessageTooManyEntries) { | |
152 CryptoHandshakeMessage message; | |
153 message.tag = 0xFFAA7733; | |
154 for (uint32 key = 1; key <= kMaxEntries + 1; key++) { | |
155 message.tag_value_map[key] = "abcdef"; | |
156 } | |
157 | |
158 CryptoFramer framer; | |
159 QuicData* data; | |
160 EXPECT_FALSE(framer.ConstructHandshakeMessage(message, &data)); | |
161 } | |
jar (doing other things)
2012/10/14 23:04:38
nit: maybe delete data;
Ryan Hamilton
2012/10/15 21:22:08
Given that data will be uninitialized unless the t
jar (doing other things)
2012/10/15 23:54:32
Not a big deal... but init to NULL, and then just
Ryan Hamilton
2012/10/16 00:03:56
Done.
| |
162 | |
163 | |
164 TEST(CryptoFramerTest, ConstructHandshakeMessageInvalidLength) { | |
165 CryptoHandshakeMessage message; | |
166 message.tag = 0xFFAA7733; | |
167 message.tag_value_map[0x12345678] = ""; | |
168 | |
169 CryptoFramer framer; | |
170 QuicData* data; | |
171 EXPECT_FALSE(framer.ConstructHandshakeMessage(message, &data)); | |
172 } | |
173 | |
174 TEST(CryptoFramerTest, EmptyPacket) { | |
175 test::TestCryptoVisitor visitor; | |
176 CryptoFramer framer; | |
177 framer.set_visitor(&visitor); | |
178 } | |
179 | |
180 TEST(CryptoFramerTest, ProcessInput) { | |
181 test::TestCryptoVisitor visitor; | |
182 CryptoFramer framer; | |
183 framer.set_visitor(&visitor); | |
184 | |
185 unsigned char input[] = { | |
186 // tag | |
187 0x33, 0x77, 0xAA, 0xFF, | |
188 // num entires | |
189 0x02, 0x00, | |
190 // tag 1 | |
191 0x78, 0x56, 0x34, 0x12, | |
192 // tag 2 | |
193 0x79, 0x56, 0x34, 0x12, | |
194 // len 1 | |
195 0x06, 0x00, | |
196 // len 2 | |
197 0x05, 0x00, | |
198 // value 1 | |
199 'a', 'b', 'c', 'd', | |
200 'e', 'f', | |
201 // value 2 | |
202 'g', 'h', 'i', 'j', | |
203 'k', | |
204 }; | |
205 | |
206 EXPECT_TRUE(framer.ProcessInput(StringPiece(AsChars(input), arraysize(input))) ); | |
jar (doing other things)
2012/10/14 23:04:38
nit: wrap line.
Ryan Hamilton
2012/10/15 21:22:08
Done.
| |
207 ASSERT_EQ(1u, visitor.message_tags_.size()); | |
208 EXPECT_EQ(0xFFAA7733, visitor.message_tags_[0]); | |
209 EXPECT_EQ(2u, visitor.message_maps_[0].size()); | |
210 EXPECT_EQ("abcdef",visitor.message_maps_[0][0x12345678]); | |
211 EXPECT_EQ("ghijk", visitor.message_maps_[0][0x12345679]); | |
212 } | |
213 | |
214 TEST(CryptoFramerTest, ProcessInputIncrementally) { | |
215 test::TestCryptoVisitor visitor; | |
216 CryptoFramer framer; | |
217 framer.set_visitor(&visitor); | |
218 | |
219 unsigned char input[] = { | |
220 // tag | |
221 0x33, 0x77, 0xAA, 0xFF, | |
222 // num entires | |
223 0x02, 0x00, | |
224 // tag 1 | |
225 0x78, 0x56, 0x34, 0x12, | |
226 // tag 2 | |
227 0x79, 0x56, 0x34, 0x12, | |
228 // len 1 | |
229 0x06, 0x00, | |
230 // len 2 | |
231 0x05, 0x00, | |
232 // value 1 | |
233 'a', 'b', 'c', 'd', | |
234 'e', 'f', | |
235 // value 2 | |
236 'g', 'h', 'i', 'j', | |
237 'k', | |
238 }; | |
239 | |
240 for (size_t i = 0; i < arraysize(input); i++) { | |
241 EXPECT_TRUE(framer.ProcessInput(StringPiece(AsChars(input)+ i, 1))); | |
242 } | |
243 ASSERT_EQ(1u, visitor.message_tags_.size()); | |
244 EXPECT_EQ(0xFFAA7733, visitor.message_tags_[0]); | |
245 EXPECT_EQ(2u, visitor.message_maps_[0].size()); | |
246 EXPECT_EQ("abcdef",visitor.message_maps_[0][0x12345678]); | |
247 EXPECT_EQ("ghijk", visitor.message_maps_[0][0x12345679]); | |
248 } | |
249 | |
250 TEST(CryptoFramerTest, ProcessInputTagsOutOfOrder) { | |
251 test::TestCryptoVisitor visitor; | |
252 CryptoFramer framer; | |
253 framer.set_visitor(&visitor); | |
254 | |
255 unsigned char input[] = { | |
256 // tag | |
257 0x33, 0x77, 0xAA, 0xFF, | |
258 // num entires | |
259 0x02, 0x00, | |
260 // tag 1 | |
261 0x79, 0x56, 0x34, 0x12, | |
262 // tag 2 | |
263 0x78, 0x56, 0x34, 0x12, | |
264 }; | |
265 | |
266 EXPECT_FALSE(framer.ProcessInput(StringPiece(AsChars(input), arraysize(input)) )); | |
jar (doing other things)
2012/10/14 23:04:38
nit: wrap
Ryan Hamilton
2012/10/15 21:22:08
Done.
| |
267 EXPECT_EQ(QUIC_CRYPTO_TAGS_OUT_OF_ORDER, framer.error()); | |
268 } | |
269 | |
270 TEST(CryptoFramerTest, ProcessInputTooManyEntries) { | |
271 test::TestCryptoVisitor visitor; | |
272 CryptoFramer framer; | |
273 framer.set_visitor(&visitor); | |
274 | |
275 unsigned char input[] = { | |
276 // tag | |
277 0x33, 0x77, 0xAA, 0xFF, | |
278 // num entires | |
279 0xA0, 0x00, | |
280 }; | |
281 | |
282 EXPECT_FALSE(framer.ProcessInput(StringPiece(AsChars(input), arraysize(input)) )); | |
283 EXPECT_EQ(QUIC_CRYPTO_TOO_MANY_ENTRIES, framer.error()); | |
284 } | |
285 | |
286 TEST(CryptoFramerTest, ProcessInputInvalidLength) { | |
287 test::TestCryptoVisitor visitor; | |
288 CryptoFramer framer; | |
289 framer.set_visitor(&visitor); | |
290 | |
291 unsigned char input[] = { | |
292 // tag | |
293 0x33, 0x77, 0xAA, 0xFF, | |
294 // num entires | |
295 0x02, 0x00, | |
296 // tag 1 | |
297 0x78, 0x56, 0x34, 0x12, | |
298 // tag 2 | |
299 0x79, 0x56, 0x34, 0x12, | |
300 // len 1 | |
301 0x00, 0x00, | |
302 // len 2 | |
303 0x05, 0x00, | |
304 }; | |
305 | |
306 EXPECT_FALSE(framer.ProcessInput(StringPiece(AsChars(input), arraysize(input)) )); | |
jar (doing other things)
2012/10/14 23:04:38
nit: wrap
Ryan Hamilton
2012/10/15 21:22:08
Done.
| |
307 EXPECT_EQ(QUIC_CRYPTO_INVALID_VALUE_LENGTH, framer.error()); | |
308 } | |
309 | |
310 } // namespace net | |
OLD | NEW |