OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 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 "net/ssl/channel_id_service.h" | 5 #include "net/ssl/channel_id_service.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
11 #include "base/memory/scoped_ptr.h" | 11 #include "base/memory/scoped_ptr.h" |
12 #include "base/message_loop/message_loop.h" | 12 #include "base/message_loop/message_loop.h" |
13 #include "base/message_loop/message_loop_proxy.h" | 13 #include "base/message_loop/message_loop_proxy.h" |
14 #include "base/strings/string_number_conversions.h" | |
14 #include "base/task_runner.h" | 15 #include "base/task_runner.h" |
15 #include "crypto/ec_private_key.h" | 16 #include "crypto/ec_private_key.h" |
16 #include "net/base/net_errors.h" | 17 #include "net/base/net_errors.h" |
17 #include "net/base/test_completion_callback.h" | 18 #include "net/base/test_completion_callback.h" |
18 #include "net/cert/asn1_util.h" | 19 #include "net/cert/asn1_util.h" |
19 #include "net/cert/x509_certificate.h" | 20 #include "net/cert/x509_certificate.h" |
20 #include "net/ssl/default_channel_id_store.h" | 21 #include "net/ssl/default_channel_id_store.h" |
21 #include "testing/gtest/include/gtest/gtest.h" | 22 #include "testing/gtest/include/gtest/gtest.h" |
22 | 23 |
23 namespace net { | 24 namespace net { |
(...skipping 26 matching lines...) Expand all Loading... | |
50 DISALLOW_COPY_AND_ASSIGN(FailingTaskRunner); | 51 DISALLOW_COPY_AND_ASSIGN(FailingTaskRunner); |
51 }; | 52 }; |
52 | 53 |
53 class MockChannelIDStoreWithAsyncGet | 54 class MockChannelIDStoreWithAsyncGet |
54 : public DefaultChannelIDStore { | 55 : public DefaultChannelIDStore { |
55 public: | 56 public: |
56 MockChannelIDStoreWithAsyncGet() | 57 MockChannelIDStoreWithAsyncGet() |
57 : DefaultChannelIDStore(NULL), channel_id_count_(0) {} | 58 : DefaultChannelIDStore(NULL), channel_id_count_(0) {} |
58 | 59 |
59 int GetChannelID(const std::string& server_identifier, | 60 int GetChannelID(const std::string& server_identifier, |
60 base::Time* expiration_time, | |
61 std::string* private_key_result, | 61 std::string* private_key_result, |
62 std::string* cert_result, | 62 std::string* public_key_result, |
63 const GetChannelIDCallback& callback) override; | 63 const GetChannelIDCallback& callback) override; |
64 | 64 |
65 void SetChannelID(const std::string& server_identifier, | 65 void SetChannelID(const std::string& server_identifier, |
66 base::Time creation_time, | 66 base::Time creation_time, |
67 base::Time expiration_time, | |
68 const std::string& private_key, | 67 const std::string& private_key, |
69 const std::string& cert) override { | 68 const std::string& public_key) override { |
70 channel_id_count_ = 1; | 69 channel_id_count_ = 1; |
71 } | 70 } |
72 | 71 |
73 int GetChannelIDCount() override { return channel_id_count_; } | 72 int GetChannelIDCount() override { return channel_id_count_; } |
74 | 73 |
75 void CallGetChannelIDCallbackWithResult(int err, | 74 void CallGetChannelIDCallbackWithResult(int err, |
76 base::Time expiration_time, | |
77 const std::string& private_key, | 75 const std::string& private_key, |
78 const std::string& cert); | 76 const std::string& public_key); |
79 | 77 |
80 private: | 78 private: |
81 GetChannelIDCallback callback_; | 79 GetChannelIDCallback callback_; |
82 std::string server_identifier_; | 80 std::string server_identifier_; |
83 int channel_id_count_; | 81 int channel_id_count_; |
84 }; | 82 }; |
85 | 83 |
86 int MockChannelIDStoreWithAsyncGet::GetChannelID( | 84 int MockChannelIDStoreWithAsyncGet::GetChannelID( |
87 const std::string& server_identifier, | 85 const std::string& server_identifier, |
88 base::Time* expiration_time, | |
89 std::string* private_key_result, | 86 std::string* private_key_result, |
90 std::string* cert_result, | 87 std::string* cert_result, |
91 const GetChannelIDCallback& callback) { | 88 const GetChannelIDCallback& callback) { |
92 server_identifier_ = server_identifier; | 89 server_identifier_ = server_identifier; |
93 callback_ = callback; | 90 callback_ = callback; |
94 // Reset the cert count, it'll get incremented in either SetChannelID or | 91 // Reset the cert count, it'll get incremented in either SetChannelID or |
95 // CallGetChannelIDCallbackWithResult. | 92 // CallGetChannelIDCallbackWithResult. |
96 channel_id_count_ = 0; | 93 channel_id_count_ = 0; |
97 // Do nothing else: the results to be provided will be specified through | 94 // Do nothing else: the results to be provided will be specified through |
98 // CallGetChannelIDCallbackWithResult. | 95 // CallGetChannelIDCallbackWithResult. |
99 return ERR_IO_PENDING; | 96 return ERR_IO_PENDING; |
100 } | 97 } |
101 | 98 |
102 void | 99 void MockChannelIDStoreWithAsyncGet::CallGetChannelIDCallbackWithResult( |
103 MockChannelIDStoreWithAsyncGet::CallGetChannelIDCallbackWithResult( | |
104 int err, | 100 int err, |
105 base::Time expiration_time, | |
106 const std::string& private_key, | 101 const std::string& private_key, |
107 const std::string& cert) { | 102 const std::string& public_key) { |
108 if (err == OK) | 103 if (err == OK) |
109 channel_id_count_ = 1; | 104 channel_id_count_ = 1; |
110 base::MessageLoop::current()->PostTask(FROM_HERE, | 105 base::MessageLoop::current()->PostTask( |
111 base::Bind(callback_, | 106 FROM_HERE, |
112 err, | 107 base::Bind(callback_, err, server_identifier_, private_key, public_key)); |
113 server_identifier_, | |
114 expiration_time, | |
115 private_key, | |
116 cert)); | |
117 } | 108 } |
118 | 109 |
119 class ChannelIDServiceTest : public testing::Test { | 110 class ChannelIDServiceTest : public testing::Test { |
120 public: | 111 public: |
121 ChannelIDServiceTest() | 112 ChannelIDServiceTest() |
122 : service_(new ChannelIDService( | 113 : service_(new ChannelIDService( |
123 new DefaultChannelIDStore(NULL), | 114 new DefaultChannelIDStore(NULL), |
124 base::MessageLoopProxy::current())) { | 115 base::MessageLoopProxy::current())) { |
125 } | 116 } |
126 | 117 |
127 protected: | 118 protected: |
128 scoped_ptr<ChannelIDService> service_; | 119 scoped_ptr<ChannelIDService> service_; |
129 }; | 120 }; |
130 | 121 |
122 void ExpectKeysEqual(const scoped_ptr<crypto::ECPrivateKey>& key1, | |
123 const scoped_ptr<crypto::ECPrivateKey>& key2) { | |
124 EXPECT_TRUE(key1); | |
125 EXPECT_TRUE(key2); | |
mattm
2015/04/27 20:55:53
Still should be ASSERTs
nharper
2015/04/29 22:07:15
Done.
| |
126 std::string public_key1, public_key2; | |
127 EXPECT_TRUE(key1->ExportRawPublicKey(&public_key1) && | |
128 key2->ExportRawPublicKey(&public_key2)); | |
129 EXPECT_EQ(public_key1, public_key2); | |
130 } | |
131 | |
131 TEST_F(ChannelIDServiceTest, GetDomainForHost) { | 132 TEST_F(ChannelIDServiceTest, GetDomainForHost) { |
132 EXPECT_EQ("google.com", | 133 EXPECT_EQ("google.com", |
133 ChannelIDService::GetDomainForHost("google.com")); | 134 ChannelIDService::GetDomainForHost("google.com")); |
134 EXPECT_EQ("google.com", | 135 EXPECT_EQ("google.com", |
135 ChannelIDService::GetDomainForHost("www.google.com")); | 136 ChannelIDService::GetDomainForHost("www.google.com")); |
136 EXPECT_EQ("foo.appspot.com", | 137 EXPECT_EQ("foo.appspot.com", |
137 ChannelIDService::GetDomainForHost("foo.appspot.com")); | 138 ChannelIDService::GetDomainForHost("foo.appspot.com")); |
138 EXPECT_EQ("bar.appspot.com", | 139 EXPECT_EQ("bar.appspot.com", |
139 ChannelIDService::GetDomainForHost("foo.bar.appspot.com")); | 140 ChannelIDService::GetDomainForHost("foo.bar.appspot.com")); |
140 EXPECT_EQ("appspot.com", | 141 EXPECT_EQ("appspot.com", |
141 ChannelIDService::GetDomainForHost("appspot.com")); | 142 ChannelIDService::GetDomainForHost("appspot.com")); |
142 EXPECT_EQ("google.com", | 143 EXPECT_EQ("google.com", |
143 ChannelIDService::GetDomainForHost("www.mail.google.com")); | 144 ChannelIDService::GetDomainForHost("www.mail.google.com")); |
144 EXPECT_EQ("goto", | 145 EXPECT_EQ("goto", |
145 ChannelIDService::GetDomainForHost("goto")); | 146 ChannelIDService::GetDomainForHost("goto")); |
146 EXPECT_EQ("127.0.0.1", | 147 EXPECT_EQ("127.0.0.1", |
147 ChannelIDService::GetDomainForHost("127.0.0.1")); | 148 ChannelIDService::GetDomainForHost("127.0.0.1")); |
148 } | 149 } |
149 | 150 |
150 TEST_F(ChannelIDServiceTest, GetCacheMiss) { | 151 TEST_F(ChannelIDServiceTest, GetCacheMiss) { |
151 std::string host("encrypted.google.com"); | 152 std::string host("encrypted.google.com"); |
152 | 153 |
153 int error; | 154 int error; |
154 TestCompletionCallback callback; | 155 TestCompletionCallback callback; |
155 ChannelIDService::RequestHandle request_handle; | 156 ChannelIDService::RequestHandle request_handle; |
156 | 157 |
157 // Synchronous completion, because the store is initialized. | 158 // Synchronous completion, because the store is initialized. |
158 std::string private_key, der_cert; | 159 scoped_ptr<crypto::ECPrivateKey> key; |
159 EXPECT_EQ(0, service_->cert_count()); | 160 EXPECT_EQ(0, service_->cert_count()); |
160 error = service_->GetChannelID( | 161 error = |
161 host, &private_key, &der_cert, callback.callback(), &request_handle); | 162 service_->GetChannelID(host, &key, callback.callback(), &request_handle); |
162 EXPECT_EQ(ERR_FILE_NOT_FOUND, error); | 163 EXPECT_EQ(ERR_FILE_NOT_FOUND, error); |
163 EXPECT_FALSE(request_handle.is_active()); | 164 EXPECT_FALSE(request_handle.is_active()); |
164 EXPECT_EQ(0, service_->cert_count()); | 165 EXPECT_EQ(0, service_->cert_count()); |
165 EXPECT_TRUE(der_cert.empty()); | 166 EXPECT_FALSE(key); |
166 } | 167 } |
167 | 168 |
168 TEST_F(ChannelIDServiceTest, CacheHit) { | 169 TEST_F(ChannelIDServiceTest, CacheHit) { |
169 std::string host("encrypted.google.com"); | 170 std::string host("encrypted.google.com"); |
170 | 171 |
171 int error; | 172 int error; |
172 TestCompletionCallback callback; | 173 TestCompletionCallback callback; |
173 ChannelIDService::RequestHandle request_handle; | 174 ChannelIDService::RequestHandle request_handle; |
174 | 175 |
175 // Asynchronous completion. | 176 // Asynchronous completion. |
176 std::string private_key_info1, der_cert1; | 177 scoped_ptr<crypto::ECPrivateKey> key1; |
177 EXPECT_EQ(0, service_->cert_count()); | 178 EXPECT_EQ(0, service_->cert_count()); |
178 error = service_->GetOrCreateChannelID( | 179 error = service_->GetOrCreateChannelID(host, &key1, callback.callback(), |
179 host, &private_key_info1, &der_cert1, | 180 &request_handle); |
180 callback.callback(), &request_handle); | |
181 EXPECT_EQ(ERR_IO_PENDING, error); | 181 EXPECT_EQ(ERR_IO_PENDING, error); |
182 EXPECT_TRUE(request_handle.is_active()); | 182 EXPECT_TRUE(request_handle.is_active()); |
183 error = callback.WaitForResult(); | 183 error = callback.WaitForResult(); |
184 EXPECT_EQ(OK, error); | 184 EXPECT_EQ(OK, error); |
185 EXPECT_EQ(1, service_->cert_count()); | 185 EXPECT_EQ(1, service_->cert_count()); |
186 EXPECT_FALSE(private_key_info1.empty()); | 186 EXPECT_TRUE(key1); |
187 EXPECT_FALSE(der_cert1.empty()); | |
188 EXPECT_FALSE(request_handle.is_active()); | 187 EXPECT_FALSE(request_handle.is_active()); |
189 | 188 |
190 // Synchronous completion. | 189 // Synchronous completion. |
191 std::string private_key_info2, der_cert2; | 190 scoped_ptr<crypto::ECPrivateKey> key2; |
192 error = service_->GetOrCreateChannelID( | 191 error = service_->GetOrCreateChannelID(host, &key2, callback.callback(), |
193 host, &private_key_info2, &der_cert2, | 192 &request_handle); |
194 callback.callback(), &request_handle); | |
195 EXPECT_FALSE(request_handle.is_active()); | 193 EXPECT_FALSE(request_handle.is_active()); |
196 EXPECT_EQ(OK, error); | 194 EXPECT_EQ(OK, error); |
197 EXPECT_EQ(1, service_->cert_count()); | 195 EXPECT_EQ(1, service_->cert_count()); |
198 EXPECT_EQ(private_key_info1, private_key_info2); | 196 ExpectKeysEqual(key1, key2); |
199 EXPECT_EQ(der_cert1, der_cert2); | |
200 | 197 |
201 // Synchronous get. | 198 // Synchronous get. |
202 std::string private_key_info3, der_cert3; | 199 scoped_ptr<crypto::ECPrivateKey> key3; |
203 error = service_->GetChannelID( | 200 error = |
204 host, &private_key_info3, &der_cert3, callback.callback(), | 201 service_->GetChannelID(host, &key3, callback.callback(), &request_handle); |
205 &request_handle); | |
206 EXPECT_FALSE(request_handle.is_active()); | 202 EXPECT_FALSE(request_handle.is_active()); |
207 EXPECT_EQ(OK, error); | 203 EXPECT_EQ(OK, error); |
208 EXPECT_EQ(1, service_->cert_count()); | 204 EXPECT_EQ(1, service_->cert_count()); |
209 EXPECT_EQ(der_cert1, der_cert3); | 205 ExpectKeysEqual(key1, key3); |
210 EXPECT_EQ(private_key_info1, private_key_info3); | |
211 | 206 |
212 EXPECT_EQ(3u, service_->requests()); | 207 EXPECT_EQ(3u, service_->requests()); |
213 EXPECT_EQ(2u, service_->cert_store_hits()); | 208 EXPECT_EQ(2u, service_->key_store_hits()); |
214 EXPECT_EQ(0u, service_->inflight_joins()); | 209 EXPECT_EQ(0u, service_->inflight_joins()); |
215 } | 210 } |
216 | 211 |
217 TEST_F(ChannelIDServiceTest, StoreChannelIDs) { | 212 TEST_F(ChannelIDServiceTest, StoreChannelIDs) { |
218 int error; | 213 int error; |
219 TestCompletionCallback callback; | 214 TestCompletionCallback callback; |
220 ChannelIDService::RequestHandle request_handle; | 215 ChannelIDService::RequestHandle request_handle; |
221 | 216 |
222 std::string host1("encrypted.google.com"); | 217 std::string host1("encrypted.google.com"); |
223 std::string private_key_info1, der_cert1; | 218 scoped_ptr<crypto::ECPrivateKey> key1; |
224 EXPECT_EQ(0, service_->cert_count()); | 219 EXPECT_EQ(0, service_->cert_count()); |
225 error = service_->GetOrCreateChannelID( | 220 error = service_->GetOrCreateChannelID(host1, &key1, callback.callback(), |
226 host1, &private_key_info1, &der_cert1, | 221 &request_handle); |
227 callback.callback(), &request_handle); | |
228 EXPECT_EQ(ERR_IO_PENDING, error); | 222 EXPECT_EQ(ERR_IO_PENDING, error); |
229 EXPECT_TRUE(request_handle.is_active()); | 223 EXPECT_TRUE(request_handle.is_active()); |
230 error = callback.WaitForResult(); | 224 error = callback.WaitForResult(); |
231 EXPECT_EQ(OK, error); | 225 EXPECT_EQ(OK, error); |
232 EXPECT_EQ(1, service_->cert_count()); | 226 EXPECT_EQ(1, service_->cert_count()); |
233 | 227 |
234 std::string host2("www.verisign.com"); | 228 std::string host2("www.verisign.com"); |
235 std::string private_key_info2, der_cert2; | 229 scoped_ptr<crypto::ECPrivateKey> key2; |
236 error = service_->GetOrCreateChannelID( | 230 error = service_->GetOrCreateChannelID(host2, &key2, callback.callback(), |
237 host2, &private_key_info2, &der_cert2, | 231 &request_handle); |
238 callback.callback(), &request_handle); | |
239 EXPECT_EQ(ERR_IO_PENDING, error); | 232 EXPECT_EQ(ERR_IO_PENDING, error); |
240 EXPECT_TRUE(request_handle.is_active()); | 233 EXPECT_TRUE(request_handle.is_active()); |
241 error = callback.WaitForResult(); | 234 error = callback.WaitForResult(); |
242 EXPECT_EQ(OK, error); | 235 EXPECT_EQ(OK, error); |
243 EXPECT_EQ(2, service_->cert_count()); | 236 EXPECT_EQ(2, service_->cert_count()); |
244 | 237 |
245 std::string host3("www.twitter.com"); | 238 std::string host3("www.twitter.com"); |
246 std::string private_key_info3, der_cert3; | 239 scoped_ptr<crypto::ECPrivateKey> key3; |
247 error = service_->GetOrCreateChannelID( | 240 error = service_->GetOrCreateChannelID(host3, &key3, callback.callback(), |
248 host3, &private_key_info3, &der_cert3, | 241 &request_handle); |
249 callback.callback(), &request_handle); | |
250 EXPECT_EQ(ERR_IO_PENDING, error); | 242 EXPECT_EQ(ERR_IO_PENDING, error); |
251 EXPECT_TRUE(request_handle.is_active()); | 243 EXPECT_TRUE(request_handle.is_active()); |
252 error = callback.WaitForResult(); | 244 error = callback.WaitForResult(); |
253 EXPECT_EQ(OK, error); | 245 EXPECT_EQ(OK, error); |
254 EXPECT_EQ(3, service_->cert_count()); | 246 EXPECT_EQ(3, service_->cert_count()); |
255 | 247 |
256 EXPECT_NE(private_key_info1, private_key_info2); | 248 EXPECT_NE(key1.get(), key2.get()); |
257 EXPECT_NE(der_cert1, der_cert2); | 249 EXPECT_NE(key1.get(), key3.get()); |
258 EXPECT_NE(private_key_info1, private_key_info3); | 250 EXPECT_NE(key2.get(), key3.get()); |
259 EXPECT_NE(der_cert1, der_cert3); | |
260 EXPECT_NE(private_key_info2, private_key_info3); | |
261 EXPECT_NE(der_cert2, der_cert3); | |
262 } | 251 } |
263 | 252 |
264 // Tests an inflight join. | 253 // Tests an inflight join. |
265 TEST_F(ChannelIDServiceTest, InflightJoin) { | 254 TEST_F(ChannelIDServiceTest, InflightJoin) { |
266 std::string host("encrypted.google.com"); | 255 std::string host("encrypted.google.com"); |
267 int error; | 256 int error; |
268 | 257 |
269 std::string private_key_info1, der_cert1; | 258 scoped_ptr<crypto::ECPrivateKey> key1; |
270 TestCompletionCallback callback1; | 259 TestCompletionCallback callback1; |
271 ChannelIDService::RequestHandle request_handle1; | 260 ChannelIDService::RequestHandle request_handle1; |
272 | 261 |
273 std::string private_key_info2, der_cert2; | 262 scoped_ptr<crypto::ECPrivateKey> key2; |
274 TestCompletionCallback callback2; | 263 TestCompletionCallback callback2; |
275 ChannelIDService::RequestHandle request_handle2; | 264 ChannelIDService::RequestHandle request_handle2; |
276 | 265 |
277 error = service_->GetOrCreateChannelID( | 266 error = service_->GetOrCreateChannelID(host, &key1, callback1.callback(), |
278 host, &private_key_info1, &der_cert1, | 267 &request_handle1); |
279 callback1.callback(), &request_handle1); | |
280 EXPECT_EQ(ERR_IO_PENDING, error); | 268 EXPECT_EQ(ERR_IO_PENDING, error); |
281 EXPECT_TRUE(request_handle1.is_active()); | 269 EXPECT_TRUE(request_handle1.is_active()); |
282 // Should join with the original request. | 270 // Should join with the original request. |
283 error = service_->GetOrCreateChannelID( | 271 error = service_->GetOrCreateChannelID(host, &key2, callback2.callback(), |
284 host, &private_key_info2, &der_cert2, | 272 &request_handle2); |
285 callback2.callback(), &request_handle2); | |
286 EXPECT_EQ(ERR_IO_PENDING, error); | 273 EXPECT_EQ(ERR_IO_PENDING, error); |
287 EXPECT_TRUE(request_handle2.is_active()); | 274 EXPECT_TRUE(request_handle2.is_active()); |
288 | 275 |
289 error = callback1.WaitForResult(); | 276 error = callback1.WaitForResult(); |
290 EXPECT_EQ(OK, error); | 277 EXPECT_EQ(OK, error); |
291 error = callback2.WaitForResult(); | 278 error = callback2.WaitForResult(); |
292 EXPECT_EQ(OK, error); | 279 EXPECT_EQ(OK, error); |
293 | 280 |
294 EXPECT_EQ(2u, service_->requests()); | 281 EXPECT_EQ(2u, service_->requests()); |
295 EXPECT_EQ(0u, service_->cert_store_hits()); | 282 EXPECT_EQ(0u, service_->key_store_hits()); |
296 EXPECT_EQ(1u, service_->inflight_joins()); | 283 EXPECT_EQ(1u, service_->inflight_joins()); |
297 EXPECT_EQ(1u, service_->workers_created()); | 284 EXPECT_EQ(1u, service_->workers_created()); |
298 } | 285 } |
299 | 286 |
300 // Tests an inflight join of a Get request to a GetOrCreate request. | 287 // Tests an inflight join of a Get request to a GetOrCreate request. |
301 TEST_F(ChannelIDServiceTest, InflightJoinGetOrCreateAndGet) { | 288 TEST_F(ChannelIDServiceTest, InflightJoinGetOrCreateAndGet) { |
302 std::string host("encrypted.google.com"); | 289 std::string host("encrypted.google.com"); |
303 int error; | 290 int error; |
304 | 291 |
305 std::string private_key_info1, der_cert1; | 292 scoped_ptr<crypto::ECPrivateKey> key1; |
306 TestCompletionCallback callback1; | 293 TestCompletionCallback callback1; |
307 ChannelIDService::RequestHandle request_handle1; | 294 ChannelIDService::RequestHandle request_handle1; |
308 | 295 |
309 std::string private_key_info2; | 296 scoped_ptr<crypto::ECPrivateKey> key2; |
310 std::string der_cert2; | |
311 TestCompletionCallback callback2; | 297 TestCompletionCallback callback2; |
312 ChannelIDService::RequestHandle request_handle2; | 298 ChannelIDService::RequestHandle request_handle2; |
313 | 299 |
314 error = service_->GetOrCreateChannelID( | 300 error = service_->GetOrCreateChannelID(host, &key1, callback1.callback(), |
315 host, &private_key_info1, &der_cert1, | 301 &request_handle1); |
316 callback1.callback(), &request_handle1); | |
317 EXPECT_EQ(ERR_IO_PENDING, error); | 302 EXPECT_EQ(ERR_IO_PENDING, error); |
318 EXPECT_TRUE(request_handle1.is_active()); | 303 EXPECT_TRUE(request_handle1.is_active()); |
319 // Should join with the original request. | 304 // Should join with the original request. |
320 error = service_->GetChannelID( | 305 error = service_->GetChannelID(host, &key2, callback2.callback(), |
321 host, &private_key_info2, &der_cert2, callback2.callback(), | 306 &request_handle2); |
322 &request_handle2); | |
323 EXPECT_EQ(ERR_IO_PENDING, error); | 307 EXPECT_EQ(ERR_IO_PENDING, error); |
324 EXPECT_TRUE(request_handle2.is_active()); | 308 EXPECT_TRUE(request_handle2.is_active()); |
325 | 309 |
326 error = callback1.WaitForResult(); | 310 error = callback1.WaitForResult(); |
327 EXPECT_EQ(OK, error); | 311 EXPECT_EQ(OK, error); |
328 error = callback2.WaitForResult(); | 312 error = callback2.WaitForResult(); |
329 EXPECT_EQ(OK, error); | 313 EXPECT_EQ(OK, error); |
330 EXPECT_EQ(der_cert1, der_cert2); | 314 ExpectKeysEqual(key1, key2); |
331 | 315 |
332 EXPECT_EQ(2u, service_->requests()); | 316 EXPECT_EQ(2u, service_->requests()); |
333 EXPECT_EQ(0u, service_->cert_store_hits()); | 317 EXPECT_EQ(0u, service_->key_store_hits()); |
334 EXPECT_EQ(1u, service_->inflight_joins()); | 318 EXPECT_EQ(1u, service_->inflight_joins()); |
335 EXPECT_EQ(1u, service_->workers_created()); | 319 EXPECT_EQ(1u, service_->workers_created()); |
336 } | 320 } |
337 | 321 |
338 TEST_F(ChannelIDServiceTest, ExtractValuesFromBytesEC) { | 322 TEST_F(ChannelIDServiceTest, ExtractValuesFromBytesEC) { |
339 std::string host("encrypted.google.com"); | 323 std::string host("encrypted.google.com"); |
340 std::string private_key_info, der_cert; | 324 scoped_ptr<crypto::ECPrivateKey> key; |
341 int error; | 325 int error; |
342 TestCompletionCallback callback; | 326 TestCompletionCallback callback; |
343 ChannelIDService::RequestHandle request_handle; | 327 ChannelIDService::RequestHandle request_handle; |
344 | 328 |
345 error = service_->GetOrCreateChannelID( | 329 error = service_->GetOrCreateChannelID(host, &key, callback.callback(), |
346 host, &private_key_info, &der_cert, callback.callback(), | 330 &request_handle); |
347 &request_handle); | |
348 EXPECT_EQ(ERR_IO_PENDING, error); | 331 EXPECT_EQ(ERR_IO_PENDING, error); |
349 EXPECT_TRUE(request_handle.is_active()); | 332 EXPECT_TRUE(request_handle.is_active()); |
350 error = callback.WaitForResult(); | 333 error = callback.WaitForResult(); |
351 EXPECT_EQ(OK, error); | 334 EXPECT_EQ(OK, error); |
352 | 335 |
353 base::StringPiece spki_piece; | 336 EXPECT_TRUE(key); |
354 ASSERT_TRUE(asn1::ExtractSPKIFromDERCert(der_cert, &spki_piece)); | |
355 std::vector<uint8> spki( | |
356 spki_piece.data(), | |
357 spki_piece.data() + spki_piece.size()); | |
358 | |
359 // Check that we can retrieve the key from the bytes. | |
360 std::vector<uint8> key_vec(private_key_info.begin(), private_key_info.end()); | |
361 scoped_ptr<crypto::ECPrivateKey> private_key( | |
362 crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( | |
363 ChannelIDService::kEPKIPassword, key_vec, spki)); | |
364 EXPECT_TRUE(private_key != NULL); | |
365 | |
366 // Check that we can retrieve the cert from the bytes. | |
367 scoped_refptr<X509Certificate> x509cert( | |
368 X509Certificate::CreateFromBytes(der_cert.data(), der_cert.size())); | |
369 EXPECT_TRUE(x509cert.get() != NULL); | |
370 } | 337 } |
371 | 338 |
372 // Tests that the callback of a canceled request is never made. | 339 // Tests that the callback of a canceled request is never made. |
373 TEST_F(ChannelIDServiceTest, CancelRequest) { | 340 TEST_F(ChannelIDServiceTest, CancelRequest) { |
374 std::string host("encrypted.google.com"); | 341 std::string host("encrypted.google.com"); |
375 std::string private_key_info, der_cert; | 342 scoped_ptr<crypto::ECPrivateKey> key; |
376 int error; | 343 int error; |
377 ChannelIDService::RequestHandle request_handle; | 344 ChannelIDService::RequestHandle request_handle; |
378 | 345 |
379 error = service_->GetOrCreateChannelID(host, | 346 error = service_->GetOrCreateChannelID(host, &key, base::Bind(&FailTest), |
380 &private_key_info, | |
381 &der_cert, | |
382 base::Bind(&FailTest), | |
383 &request_handle); | 347 &request_handle); |
384 EXPECT_EQ(ERR_IO_PENDING, error); | 348 EXPECT_EQ(ERR_IO_PENDING, error); |
385 EXPECT_TRUE(request_handle.is_active()); | 349 EXPECT_TRUE(request_handle.is_active()); |
386 request_handle.Cancel(); | 350 request_handle.Cancel(); |
387 EXPECT_FALSE(request_handle.is_active()); | 351 EXPECT_FALSE(request_handle.is_active()); |
388 | 352 |
389 // Wait for reply from ChannelIDServiceWorker to be posted back to the | 353 // Wait for reply from ChannelIDServiceWorker to be posted back to the |
390 // ChannelIDService. | 354 // ChannelIDService. |
391 base::MessageLoop::current()->RunUntilIdle(); | 355 base::MessageLoop::current()->RunUntilIdle(); |
392 | 356 |
393 // Even though the original request was cancelled, the service will still | 357 // Even though the original request was cancelled, the service will still |
394 // store the result, it just doesn't call the callback. | 358 // store the result, it just doesn't call the callback. |
395 EXPECT_EQ(1, service_->cert_count()); | 359 EXPECT_EQ(1, service_->cert_count()); |
396 } | 360 } |
397 | 361 |
398 // Tests that destructing the RequestHandle cancels the request. | 362 // Tests that destructing the RequestHandle cancels the request. |
399 TEST_F(ChannelIDServiceTest, CancelRequestByHandleDestruction) { | 363 TEST_F(ChannelIDServiceTest, CancelRequestByHandleDestruction) { |
400 std::string host("encrypted.google.com"); | 364 std::string host("encrypted.google.com"); |
401 std::string private_key_info, der_cert; | 365 scoped_ptr<crypto::ECPrivateKey> key; |
402 int error; | 366 int error; |
403 { | 367 { |
404 ChannelIDService::RequestHandle request_handle; | 368 ChannelIDService::RequestHandle request_handle; |
405 | 369 |
406 error = service_->GetOrCreateChannelID(host, | 370 error = service_->GetOrCreateChannelID(host, &key, base::Bind(&FailTest), |
407 &private_key_info, | |
408 &der_cert, | |
409 base::Bind(&FailTest), | |
410 &request_handle); | 371 &request_handle); |
411 EXPECT_EQ(ERR_IO_PENDING, error); | 372 EXPECT_EQ(ERR_IO_PENDING, error); |
412 EXPECT_TRUE(request_handle.is_active()); | 373 EXPECT_TRUE(request_handle.is_active()); |
413 } | 374 } |
414 | 375 |
415 // Wait for reply from ChannelIDServiceWorker to be posted back to the | 376 // Wait for reply from ChannelIDServiceWorker to be posted back to the |
416 // ChannelIDService. | 377 // ChannelIDService. |
417 base::MessageLoop::current()->RunUntilIdle(); | 378 base::MessageLoop::current()->RunUntilIdle(); |
418 | 379 |
419 // Even though the original request was cancelled, the service will still | 380 // Even though the original request was cancelled, the service will still |
420 // store the result, it just doesn't call the callback. | 381 // store the result, it just doesn't call the callback. |
421 EXPECT_EQ(1, service_->cert_count()); | 382 EXPECT_EQ(1, service_->cert_count()); |
422 } | 383 } |
423 | 384 |
424 TEST_F(ChannelIDServiceTest, DestructionWithPendingRequest) { | 385 TEST_F(ChannelIDServiceTest, DestructionWithPendingRequest) { |
425 std::string host("encrypted.google.com"); | 386 std::string host("encrypted.google.com"); |
426 std::string private_key_info, der_cert; | 387 scoped_ptr<crypto::ECPrivateKey> key; |
427 int error; | 388 int error; |
428 ChannelIDService::RequestHandle request_handle; | 389 ChannelIDService::RequestHandle request_handle; |
429 | 390 |
430 error = service_->GetOrCreateChannelID(host, | 391 error = service_->GetOrCreateChannelID(host, &key, base::Bind(&FailTest), |
431 &private_key_info, | |
432 &der_cert, | |
433 base::Bind(&FailTest), | |
434 &request_handle); | 392 &request_handle); |
435 EXPECT_EQ(ERR_IO_PENDING, error); | 393 EXPECT_EQ(ERR_IO_PENDING, error); |
436 EXPECT_TRUE(request_handle.is_active()); | 394 EXPECT_TRUE(request_handle.is_active()); |
437 | 395 |
438 // Cancel request and destroy the ChannelIDService. | 396 // Cancel request and destroy the ChannelIDService. |
439 request_handle.Cancel(); | 397 request_handle.Cancel(); |
440 service_.reset(); | 398 service_.reset(); |
441 | 399 |
442 // ChannelIDServiceWorker should not post anything back to the | 400 // ChannelIDServiceWorker should not post anything back to the |
443 // non-existent ChannelIDService, but run the loop just to be sure it | 401 // non-existent ChannelIDService, but run the loop just to be sure it |
444 // doesn't. | 402 // doesn't. |
445 base::MessageLoop::current()->RunUntilIdle(); | 403 base::MessageLoop::current()->RunUntilIdle(); |
446 | 404 |
447 // If we got here without crashing or a valgrind error, it worked. | 405 // If we got here without crashing or a valgrind error, it worked. |
448 } | 406 } |
449 | 407 |
450 // Tests that shutting down the sequenced worker pool and then making new | 408 // Tests that shutting down the sequenced worker pool and then making new |
451 // requests gracefully fails. | 409 // requests gracefully fails. |
452 // This is a regression test for http://crbug.com/236387 | 410 // This is a regression test for http://crbug.com/236387 |
453 TEST_F(ChannelIDServiceTest, RequestAfterPoolShutdown) { | 411 TEST_F(ChannelIDServiceTest, RequestAfterPoolShutdown) { |
454 scoped_refptr<FailingTaskRunner> task_runner(new FailingTaskRunner); | 412 scoped_refptr<FailingTaskRunner> task_runner(new FailingTaskRunner); |
455 service_.reset(new ChannelIDService( | 413 service_.reset(new ChannelIDService( |
456 new DefaultChannelIDStore(NULL), task_runner)); | 414 new DefaultChannelIDStore(NULL), task_runner)); |
457 | 415 |
458 // Make a request that will force synchronous completion. | 416 // Make a request that will force synchronous completion. |
459 std::string host("encrypted.google.com"); | 417 std::string host("encrypted.google.com"); |
460 std::string private_key_info, der_cert; | 418 scoped_ptr<crypto::ECPrivateKey> key; |
461 int error; | 419 int error; |
462 ChannelIDService::RequestHandle request_handle; | 420 ChannelIDService::RequestHandle request_handle; |
463 | 421 |
464 error = service_->GetOrCreateChannelID(host, | 422 error = service_->GetOrCreateChannelID(host, &key, base::Bind(&FailTest), |
465 &private_key_info, | |
466 &der_cert, | |
467 base::Bind(&FailTest), | |
468 &request_handle); | 423 &request_handle); |
469 // If we got here without crashing or a valgrind error, it worked. | 424 // If we got here without crashing or a valgrind error, it worked. |
470 ASSERT_EQ(ERR_INSUFFICIENT_RESOURCES, error); | 425 ASSERT_EQ(ERR_INSUFFICIENT_RESOURCES, error); |
471 EXPECT_FALSE(request_handle.is_active()); | 426 EXPECT_FALSE(request_handle.is_active()); |
472 } | 427 } |
473 | 428 |
474 // Tests that simultaneous creation of different certs works. | 429 // Tests that simultaneous creation of different certs works. |
475 TEST_F(ChannelIDServiceTest, SimultaneousCreation) { | 430 TEST_F(ChannelIDServiceTest, SimultaneousCreation) { |
476 int error; | 431 int error; |
477 | 432 |
478 std::string host1("encrypted.google.com"); | 433 std::string host1("encrypted.google.com"); |
479 std::string private_key_info1, der_cert1; | 434 scoped_ptr<crypto::ECPrivateKey> key1; |
480 TestCompletionCallback callback1; | 435 TestCompletionCallback callback1; |
481 ChannelIDService::RequestHandle request_handle1; | 436 ChannelIDService::RequestHandle request_handle1; |
482 | 437 |
483 std::string host2("foo.com"); | 438 std::string host2("foo.com"); |
484 std::string private_key_info2, der_cert2; | 439 scoped_ptr<crypto::ECPrivateKey> key2; |
485 TestCompletionCallback callback2; | 440 TestCompletionCallback callback2; |
486 ChannelIDService::RequestHandle request_handle2; | 441 ChannelIDService::RequestHandle request_handle2; |
487 | 442 |
488 std::string host3("bar.com"); | 443 std::string host3("bar.com"); |
489 std::string private_key_info3, der_cert3; | 444 scoped_ptr<crypto::ECPrivateKey> key3; |
490 TestCompletionCallback callback3; | 445 TestCompletionCallback callback3; |
491 ChannelIDService::RequestHandle request_handle3; | 446 ChannelIDService::RequestHandle request_handle3; |
492 | 447 |
493 error = service_->GetOrCreateChannelID(host1, | 448 error = service_->GetOrCreateChannelID(host1, &key1, callback1.callback(), |
494 &private_key_info1, | |
495 &der_cert1, | |
496 callback1.callback(), | |
497 &request_handle1); | 449 &request_handle1); |
498 EXPECT_EQ(ERR_IO_PENDING, error); | 450 EXPECT_EQ(ERR_IO_PENDING, error); |
499 EXPECT_TRUE(request_handle1.is_active()); | 451 EXPECT_TRUE(request_handle1.is_active()); |
500 | 452 |
501 error = service_->GetOrCreateChannelID(host2, | 453 error = service_->GetOrCreateChannelID(host2, &key2, callback2.callback(), |
502 &private_key_info2, | |
503 &der_cert2, | |
504 callback2.callback(), | |
505 &request_handle2); | 454 &request_handle2); |
506 EXPECT_EQ(ERR_IO_PENDING, error); | 455 EXPECT_EQ(ERR_IO_PENDING, error); |
507 EXPECT_TRUE(request_handle2.is_active()); | 456 EXPECT_TRUE(request_handle2.is_active()); |
508 | 457 |
509 error = service_->GetOrCreateChannelID(host3, | 458 error = service_->GetOrCreateChannelID(host3, &key3, callback3.callback(), |
510 &private_key_info3, | |
511 &der_cert3, | |
512 callback3.callback(), | |
513 &request_handle3); | 459 &request_handle3); |
514 EXPECT_EQ(ERR_IO_PENDING, error); | 460 EXPECT_EQ(ERR_IO_PENDING, error); |
515 EXPECT_TRUE(request_handle3.is_active()); | 461 EXPECT_TRUE(request_handle3.is_active()); |
516 | 462 |
517 error = callback1.WaitForResult(); | 463 error = callback1.WaitForResult(); |
518 EXPECT_EQ(OK, error); | 464 EXPECT_EQ(OK, error); |
519 EXPECT_FALSE(private_key_info1.empty()); | 465 EXPECT_TRUE(key1); |
520 EXPECT_FALSE(der_cert1.empty()); | |
521 | 466 |
522 error = callback2.WaitForResult(); | 467 error = callback2.WaitForResult(); |
523 EXPECT_EQ(OK, error); | 468 EXPECT_EQ(OK, error); |
524 EXPECT_FALSE(private_key_info2.empty()); | 469 EXPECT_TRUE(key2); |
525 EXPECT_FALSE(der_cert2.empty()); | |
526 | 470 |
527 error = callback3.WaitForResult(); | 471 error = callback3.WaitForResult(); |
528 EXPECT_EQ(OK, error); | 472 EXPECT_EQ(OK, error); |
529 EXPECT_FALSE(private_key_info3.empty()); | 473 EXPECT_TRUE(key3); |
530 EXPECT_FALSE(der_cert3.empty()); | |
531 | 474 |
532 EXPECT_NE(private_key_info1, private_key_info2); | 475 EXPECT_NE(key1.get(), key2.get()); |
533 EXPECT_NE(der_cert1, der_cert2); | 476 EXPECT_NE(key1.get(), key3.get()); |
534 | 477 EXPECT_NE(key2.get(), key3.get()); |
535 EXPECT_NE(private_key_info1, private_key_info3); | |
536 EXPECT_NE(der_cert1, der_cert3); | |
537 | |
538 EXPECT_NE(private_key_info2, private_key_info3); | |
539 EXPECT_NE(der_cert2, der_cert3); | |
540 | 478 |
541 EXPECT_EQ(3, service_->cert_count()); | 479 EXPECT_EQ(3, service_->cert_count()); |
542 } | 480 } |
543 | 481 |
544 TEST_F(ChannelIDServiceTest, Expiration) { | |
545 ChannelIDStore* store = service_->GetChannelIDStore(); | |
546 base::Time now = base::Time::Now(); | |
547 store->SetChannelID("good", | |
548 now, | |
549 now + base::TimeDelta::FromDays(1), | |
550 "a", | |
551 "b"); | |
552 store->SetChannelID("expired", | |
553 now - base::TimeDelta::FromDays(2), | |
554 now - base::TimeDelta::FromDays(1), | |
555 "c", | |
556 "d"); | |
557 EXPECT_EQ(2, service_->cert_count()); | |
558 | |
559 int error; | |
560 TestCompletionCallback callback; | |
561 ChannelIDService::RequestHandle request_handle; | |
562 | |
563 // Cert is valid - synchronous completion. | |
564 std::string private_key_info1, der_cert1; | |
565 error = service_->GetOrCreateChannelID( | |
566 "good", &private_key_info1, &der_cert1, | |
567 callback.callback(), &request_handle); | |
568 EXPECT_EQ(OK, error); | |
569 EXPECT_FALSE(request_handle.is_active()); | |
570 EXPECT_EQ(2, service_->cert_count()); | |
571 EXPECT_STREQ("a", private_key_info1.c_str()); | |
572 EXPECT_STREQ("b", der_cert1.c_str()); | |
573 | |
574 // Expired cert is valid as well - synchronous completion. | |
575 std::string private_key_info2, der_cert2; | |
576 error = service_->GetOrCreateChannelID( | |
577 "expired", &private_key_info2, &der_cert2, | |
578 callback.callback(), &request_handle); | |
579 EXPECT_EQ(OK, error); | |
580 EXPECT_FALSE(request_handle.is_active()); | |
581 EXPECT_EQ(2, service_->cert_count()); | |
582 EXPECT_STREQ("c", private_key_info2.c_str()); | |
583 EXPECT_STREQ("d", der_cert2.c_str()); | |
584 } | |
585 | |
586 TEST_F(ChannelIDServiceTest, AsyncStoreGetOrCreateNoChannelIDsInStore) { | 482 TEST_F(ChannelIDServiceTest, AsyncStoreGetOrCreateNoChannelIDsInStore) { |
587 MockChannelIDStoreWithAsyncGet* mock_store = | 483 MockChannelIDStoreWithAsyncGet* mock_store = |
588 new MockChannelIDStoreWithAsyncGet(); | 484 new MockChannelIDStoreWithAsyncGet(); |
589 service_ = scoped_ptr<ChannelIDService>(new ChannelIDService( | 485 service_ = scoped_ptr<ChannelIDService>(new ChannelIDService( |
590 mock_store, base::MessageLoopProxy::current())); | 486 mock_store, base::MessageLoopProxy::current())); |
591 | 487 |
592 std::string host("encrypted.google.com"); | 488 std::string host("encrypted.google.com"); |
593 | 489 |
594 int error; | 490 int error; |
595 TestCompletionCallback callback; | 491 TestCompletionCallback callback; |
596 ChannelIDService::RequestHandle request_handle; | 492 ChannelIDService::RequestHandle request_handle; |
597 | 493 |
598 // Asynchronous completion with no certs in the store. | 494 // Asynchronous completion with no certs in the store. |
599 std::string private_key_info, der_cert; | 495 scoped_ptr<crypto::ECPrivateKey> key; |
600 EXPECT_EQ(0, service_->cert_count()); | 496 EXPECT_EQ(0, service_->cert_count()); |
601 error = service_->GetOrCreateChannelID( | 497 error = service_->GetOrCreateChannelID(host, &key, callback.callback(), |
602 host, &private_key_info, &der_cert, callback.callback(), &request_handle); | 498 &request_handle); |
603 EXPECT_EQ(ERR_IO_PENDING, error); | 499 EXPECT_EQ(ERR_IO_PENDING, error); |
604 EXPECT_TRUE(request_handle.is_active()); | 500 EXPECT_TRUE(request_handle.is_active()); |
605 | 501 |
606 mock_store->CallGetChannelIDCallbackWithResult( | 502 mock_store->CallGetChannelIDCallbackWithResult(ERR_FILE_NOT_FOUND, |
607 ERR_FILE_NOT_FOUND, base::Time(), std::string(), std::string()); | 503 std::string(), std::string()); |
608 | 504 |
609 error = callback.WaitForResult(); | 505 error = callback.WaitForResult(); |
610 EXPECT_EQ(OK, error); | 506 EXPECT_EQ(OK, error); |
611 EXPECT_EQ(1, service_->cert_count()); | 507 EXPECT_EQ(1, service_->cert_count()); |
612 EXPECT_FALSE(private_key_info.empty()); | 508 EXPECT_TRUE(key); |
613 EXPECT_FALSE(der_cert.empty()); | |
614 EXPECT_FALSE(request_handle.is_active()); | 509 EXPECT_FALSE(request_handle.is_active()); |
615 } | 510 } |
616 | 511 |
617 TEST_F(ChannelIDServiceTest, AsyncStoreGetNoChannelIDsInStore) { | 512 TEST_F(ChannelIDServiceTest, AsyncStoreGetNoChannelIDsInStore) { |
618 MockChannelIDStoreWithAsyncGet* mock_store = | 513 MockChannelIDStoreWithAsyncGet* mock_store = |
619 new MockChannelIDStoreWithAsyncGet(); | 514 new MockChannelIDStoreWithAsyncGet(); |
620 service_ = scoped_ptr<ChannelIDService>(new ChannelIDService( | 515 service_ = scoped_ptr<ChannelIDService>(new ChannelIDService( |
621 mock_store, base::MessageLoopProxy::current())); | 516 mock_store, base::MessageLoopProxy::current())); |
622 | 517 |
623 std::string host("encrypted.google.com"); | 518 std::string host("encrypted.google.com"); |
624 | 519 |
625 int error; | 520 int error; |
626 TestCompletionCallback callback; | 521 TestCompletionCallback callback; |
627 ChannelIDService::RequestHandle request_handle; | 522 ChannelIDService::RequestHandle request_handle; |
628 | 523 |
629 // Asynchronous completion with no certs in the store. | 524 // Asynchronous completion with no certs in the store. |
630 std::string private_key, der_cert; | 525 scoped_ptr<crypto::ECPrivateKey> key; |
631 EXPECT_EQ(0, service_->cert_count()); | 526 EXPECT_EQ(0, service_->cert_count()); |
632 error = service_->GetChannelID( | 527 error = |
633 host, &private_key, &der_cert, callback.callback(), &request_handle); | 528 service_->GetChannelID(host, &key, callback.callback(), &request_handle); |
634 EXPECT_EQ(ERR_IO_PENDING, error); | 529 EXPECT_EQ(ERR_IO_PENDING, error); |
635 EXPECT_TRUE(request_handle.is_active()); | 530 EXPECT_TRUE(request_handle.is_active()); |
636 | 531 |
637 mock_store->CallGetChannelIDCallbackWithResult( | 532 mock_store->CallGetChannelIDCallbackWithResult(ERR_FILE_NOT_FOUND, |
638 ERR_FILE_NOT_FOUND, base::Time(), std::string(), std::string()); | 533 std::string(), std::string()); |
639 | 534 |
640 error = callback.WaitForResult(); | 535 error = callback.WaitForResult(); |
641 EXPECT_EQ(ERR_FILE_NOT_FOUND, error); | 536 EXPECT_EQ(ERR_FILE_NOT_FOUND, error); |
642 EXPECT_EQ(0, service_->cert_count()); | 537 EXPECT_EQ(0, service_->cert_count()); |
643 EXPECT_EQ(0u, service_->workers_created()); | 538 EXPECT_EQ(0u, service_->workers_created()); |
644 EXPECT_TRUE(der_cert.empty()); | 539 EXPECT_FALSE(key); |
645 EXPECT_FALSE(request_handle.is_active()); | 540 EXPECT_FALSE(request_handle.is_active()); |
646 } | 541 } |
647 | 542 |
648 TEST_F(ChannelIDServiceTest, AsyncStoreGetOrCreateOneCertInStore) { | 543 TEST_F(ChannelIDServiceTest, AsyncStoreGetOrCreateOneCertInStore) { |
649 MockChannelIDStoreWithAsyncGet* mock_store = | 544 MockChannelIDStoreWithAsyncGet* mock_store = |
650 new MockChannelIDStoreWithAsyncGet(); | 545 new MockChannelIDStoreWithAsyncGet(); |
651 service_ = scoped_ptr<ChannelIDService>(new ChannelIDService( | 546 service_ = scoped_ptr<ChannelIDService>(new ChannelIDService( |
652 mock_store, base::MessageLoopProxy::current())); | 547 mock_store, base::MessageLoopProxy::current())); |
653 | 548 |
654 std::string host("encrypted.google.com"); | 549 std::string host("encrypted.google.com"); |
655 | 550 |
656 int error; | 551 int error; |
657 TestCompletionCallback callback; | 552 TestCompletionCallback callback; |
658 ChannelIDService::RequestHandle request_handle; | 553 ChannelIDService::RequestHandle request_handle; |
659 | 554 |
660 // Asynchronous completion with a cert in the store. | 555 // Asynchronous completion with a cert in the store. |
661 std::string private_key_info, der_cert; | 556 scoped_ptr<crypto::ECPrivateKey> key; |
662 EXPECT_EQ(0, service_->cert_count()); | 557 EXPECT_EQ(0, service_->cert_count()); |
663 error = service_->GetOrCreateChannelID( | 558 error = service_->GetOrCreateChannelID(host, &key, callback.callback(), |
664 host, &private_key_info, &der_cert, callback.callback(), &request_handle); | 559 &request_handle); |
665 EXPECT_EQ(ERR_IO_PENDING, error); | 560 EXPECT_EQ(ERR_IO_PENDING, error); |
666 EXPECT_TRUE(request_handle.is_active()); | 561 EXPECT_TRUE(request_handle.is_active()); |
667 | 562 |
668 mock_store->CallGetChannelIDCallbackWithResult( | 563 scoped_ptr<crypto::ECPrivateKey> expected_key(crypto::ECPrivateKey::Create()); |
669 OK, base::Time(), "ab", "cd"); | 564 std::string expected_public_key, expected_private_key; |
565 ASSERT_EQ(OK, ExportKeyPair(expected_key, &expected_public_key, | |
566 &expected_private_key)); | |
567 mock_store->CallGetChannelIDCallbackWithResult(OK, expected_private_key, | |
568 expected_public_key); | |
670 | 569 |
671 error = callback.WaitForResult(); | 570 error = callback.WaitForResult(); |
672 EXPECT_EQ(OK, error); | 571 EXPECT_EQ(OK, error); |
673 EXPECT_EQ(1, service_->cert_count()); | 572 EXPECT_EQ(1, service_->cert_count()); |
674 EXPECT_EQ(1u, service_->requests()); | 573 EXPECT_EQ(1u, service_->requests()); |
675 EXPECT_EQ(1u, service_->cert_store_hits()); | 574 EXPECT_EQ(1u, service_->key_store_hits()); |
676 // Because the cert was found in the store, no new workers should have been | 575 // Because the cert was found in the store, no new workers should have been |
677 // created. | 576 // created. |
678 EXPECT_EQ(0u, service_->workers_created()); | 577 EXPECT_EQ(0u, service_->workers_created()); |
679 EXPECT_STREQ("ab", private_key_info.c_str()); | 578 EXPECT_TRUE(key); |
680 EXPECT_STREQ("cd", der_cert.c_str()); | 579 ExpectKeysEqual(expected_key, key); |
681 EXPECT_FALSE(request_handle.is_active()); | 580 EXPECT_FALSE(request_handle.is_active()); |
682 } | 581 } |
683 | 582 |
684 TEST_F(ChannelIDServiceTest, AsyncStoreGetOneCertInStore) { | 583 TEST_F(ChannelIDServiceTest, AsyncStoreGetOneCertInStore) { |
685 MockChannelIDStoreWithAsyncGet* mock_store = | 584 MockChannelIDStoreWithAsyncGet* mock_store = |
686 new MockChannelIDStoreWithAsyncGet(); | 585 new MockChannelIDStoreWithAsyncGet(); |
687 service_ = scoped_ptr<ChannelIDService>(new ChannelIDService( | 586 service_ = scoped_ptr<ChannelIDService>(new ChannelIDService( |
688 mock_store, base::MessageLoopProxy::current())); | 587 mock_store, base::MessageLoopProxy::current())); |
689 | 588 |
690 std::string host("encrypted.google.com"); | 589 std::string host("encrypted.google.com"); |
691 | 590 |
692 int error; | 591 int error; |
693 TestCompletionCallback callback; | 592 TestCompletionCallback callback; |
694 ChannelIDService::RequestHandle request_handle; | 593 ChannelIDService::RequestHandle request_handle; |
695 | 594 |
696 // Asynchronous completion with a cert in the store. | 595 // Asynchronous completion with a cert in the store. |
697 std::string private_key, der_cert; | 596 scoped_ptr<crypto::ECPrivateKey> key; |
597 std::string private_key, spki; | |
698 EXPECT_EQ(0, service_->cert_count()); | 598 EXPECT_EQ(0, service_->cert_count()); |
699 error = service_->GetChannelID( | 599 error = |
700 host, &private_key, &der_cert, callback.callback(), &request_handle); | 600 service_->GetChannelID(host, &key, callback.callback(), &request_handle); |
701 EXPECT_EQ(ERR_IO_PENDING, error); | 601 EXPECT_EQ(ERR_IO_PENDING, error); |
702 EXPECT_TRUE(request_handle.is_active()); | 602 EXPECT_TRUE(request_handle.is_active()); |
703 | 603 |
704 mock_store->CallGetChannelIDCallbackWithResult( | 604 scoped_ptr<crypto::ECPrivateKey> expected_key(crypto::ECPrivateKey::Create()); |
705 OK, base::Time(), "ab", "cd"); | 605 std::string expected_public_key, expected_private_key; |
606 ASSERT_EQ(OK, ExportKeyPair(expected_key, &expected_public_key, | |
607 &expected_private_key)); | |
608 mock_store->CallGetChannelIDCallbackWithResult(OK, expected_private_key, | |
609 expected_public_key); | |
706 | 610 |
707 error = callback.WaitForResult(); | 611 error = callback.WaitForResult(); |
708 EXPECT_EQ(OK, error); | 612 EXPECT_EQ(OK, error); |
709 EXPECT_EQ(1, service_->cert_count()); | 613 EXPECT_EQ(1, service_->cert_count()); |
710 EXPECT_EQ(1u, service_->requests()); | 614 EXPECT_EQ(1u, service_->requests()); |
711 EXPECT_EQ(1u, service_->cert_store_hits()); | 615 EXPECT_EQ(1u, service_->key_store_hits()); |
712 // Because the cert was found in the store, no new workers should have been | 616 // Because the cert was found in the store, no new workers should have been |
713 // created. | 617 // created. |
714 EXPECT_EQ(0u, service_->workers_created()); | 618 EXPECT_EQ(0u, service_->workers_created()); |
715 EXPECT_STREQ("cd", der_cert.c_str()); | 619 ExpectKeysEqual(expected_key, key); |
716 EXPECT_FALSE(request_handle.is_active()); | 620 EXPECT_FALSE(request_handle.is_active()); |
717 } | 621 } |
718 | 622 |
719 TEST_F(ChannelIDServiceTest, AsyncStoreGetThenCreateNoCertsInStore) { | 623 TEST_F(ChannelIDServiceTest, AsyncStoreGetThenCreateNoCertsInStore) { |
720 MockChannelIDStoreWithAsyncGet* mock_store = | 624 MockChannelIDStoreWithAsyncGet* mock_store = |
721 new MockChannelIDStoreWithAsyncGet(); | 625 new MockChannelIDStoreWithAsyncGet(); |
722 service_ = scoped_ptr<ChannelIDService>(new ChannelIDService( | 626 service_ = scoped_ptr<ChannelIDService>(new ChannelIDService( |
723 mock_store, base::MessageLoopProxy::current())); | 627 mock_store, base::MessageLoopProxy::current())); |
724 | 628 |
725 std::string host("encrypted.google.com"); | 629 std::string host("encrypted.google.com"); |
726 | 630 |
727 int error; | 631 int error; |
728 | 632 |
729 // Asynchronous get with no certs in the store. | 633 // Asynchronous get with no certs in the store. |
730 TestCompletionCallback callback1; | 634 TestCompletionCallback callback1; |
731 ChannelIDService::RequestHandle request_handle1; | 635 ChannelIDService::RequestHandle request_handle1; |
732 std::string private_key1, der_cert1; | 636 scoped_ptr<crypto::ECPrivateKey> key1; |
733 EXPECT_EQ(0, service_->cert_count()); | 637 EXPECT_EQ(0, service_->cert_count()); |
734 error = service_->GetChannelID( | 638 error = service_->GetChannelID(host, &key1, callback1.callback(), |
735 host, &private_key1, &der_cert1, callback1.callback(), &request_handle1); | 639 &request_handle1); |
736 EXPECT_EQ(ERR_IO_PENDING, error); | 640 EXPECT_EQ(ERR_IO_PENDING, error); |
737 EXPECT_TRUE(request_handle1.is_active()); | 641 EXPECT_TRUE(request_handle1.is_active()); |
738 | 642 |
739 // Asynchronous get/create with no certs in the store. | 643 // Asynchronous get/create with no certs in the store. |
740 TestCompletionCallback callback2; | 644 TestCompletionCallback callback2; |
741 ChannelIDService::RequestHandle request_handle2; | 645 ChannelIDService::RequestHandle request_handle2; |
742 std::string private_key2, der_cert2; | 646 scoped_ptr<crypto::ECPrivateKey> key2; |
743 EXPECT_EQ(0, service_->cert_count()); | 647 EXPECT_EQ(0, service_->cert_count()); |
744 error = service_->GetOrCreateChannelID( | 648 error = service_->GetOrCreateChannelID(host, &key2, callback2.callback(), |
745 host, &private_key2, &der_cert2, callback2.callback(), &request_handle2); | 649 &request_handle2); |
746 EXPECT_EQ(ERR_IO_PENDING, error); | 650 EXPECT_EQ(ERR_IO_PENDING, error); |
747 EXPECT_TRUE(request_handle2.is_active()); | 651 EXPECT_TRUE(request_handle2.is_active()); |
748 | 652 |
749 mock_store->CallGetChannelIDCallbackWithResult( | 653 mock_store->CallGetChannelIDCallbackWithResult(ERR_FILE_NOT_FOUND, |
750 ERR_FILE_NOT_FOUND, base::Time(), std::string(), std::string()); | 654 std::string(), std::string()); |
751 | 655 |
752 // Even though the first request didn't ask to create a cert, it gets joined | 656 // Even though the first request didn't ask to create a cert, it gets joined |
753 // by the second, which does, so both succeed. | 657 // by the second, which does, so both succeed. |
754 error = callback1.WaitForResult(); | 658 error = callback1.WaitForResult(); |
755 EXPECT_EQ(OK, error); | 659 EXPECT_EQ(OK, error); |
756 error = callback2.WaitForResult(); | 660 error = callback2.WaitForResult(); |
757 EXPECT_EQ(OK, error); | 661 EXPECT_EQ(OK, error); |
758 | 662 |
759 // One cert is created, one request is joined. | 663 // One cert is created, one request is joined. |
760 EXPECT_EQ(2U, service_->requests()); | 664 EXPECT_EQ(2U, service_->requests()); |
761 EXPECT_EQ(1, service_->cert_count()); | 665 EXPECT_EQ(1, service_->cert_count()); |
762 EXPECT_EQ(1u, service_->workers_created()); | 666 EXPECT_EQ(1u, service_->workers_created()); |
763 EXPECT_EQ(1u, service_->inflight_joins()); | 667 EXPECT_EQ(1u, service_->inflight_joins()); |
764 EXPECT_FALSE(der_cert1.empty()); | 668 EXPECT_TRUE(key1); |
765 EXPECT_EQ(der_cert1, der_cert2); | 669 ExpectKeysEqual(key1, key2); |
766 EXPECT_FALSE(private_key1.empty()); | |
767 EXPECT_EQ(private_key1, private_key2); | |
768 EXPECT_FALSE(request_handle1.is_active()); | 670 EXPECT_FALSE(request_handle1.is_active()); |
769 EXPECT_FALSE(request_handle2.is_active()); | 671 EXPECT_FALSE(request_handle2.is_active()); |
770 } | 672 } |
771 | 673 |
674 TEST_F(ChannelIDServiceTest, SerializeAndDeserializeKey) { | |
675 scoped_ptr<crypto::ECPrivateKey> expected_key(crypto::ECPrivateKey::Create()); | |
676 std::string expected_public_key, expected_private_key; | |
677 ASSERT_EQ(OK, ExportKeyPair(expected_key, &expected_public_key, | |
678 &expected_private_key)); | |
679 | |
680 scoped_ptr<crypto::ECPrivateKey> actual_key; | |
681 ASSERT_EQ(OK, CreateECPrivateKeyFromSerializedKey( | |
682 expected_public_key, expected_private_key, &actual_key)); | |
683 ExpectKeysEqual(expected_key, actual_key); | |
684 } | |
685 | |
772 } // namespace | 686 } // namespace |
773 | 687 |
774 } // namespace net | 688 } // namespace net |
OLD | NEW |