blob: eb9dc7cbed22cbc61bbce78e623d1389dd8b30c9 [file] [log] [blame]
[email protected]4b559b4d2011-04-14 17:37:141// Copyright (c) 2011 The Chromium Authors. All rights reserved.
[email protected]f61c3972010-12-23 09:54:152// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5// This test suite uses SSLClientSocket to test the implementation of
6// SSLServerSocket. In order to establish connections between the sockets
7// we need two additional classes:
8// 1. FakeSocket
9// Connects SSL socket to FakeDataChannel. This class is just a stub.
10//
11// 2. FakeDataChannel
12// Implements the actual exchange of data between two FakeSockets.
13//
14// Implementations of these two classes are included in this file.
15
16#include "net/socket/ssl_server_socket.h"
17
[email protected]55ee0e52011-07-21 18:29:4418#include <stdlib.h>
19
[email protected]f61c3972010-12-23 09:54:1520#include <queue>
21
[email protected]55ee0e52011-07-21 18:29:4422#include "base/compiler_specific.h"
[email protected]f61c3972010-12-23 09:54:1523#include "base/file_path.h"
24#include "base/file_util.h"
[email protected]55ee0e52011-07-21 18:29:4425#include "base/message_loop.h"
[email protected]f61c3972010-12-23 09:54:1526#include "base/path_service.h"
[email protected]4b559b4d2011-04-14 17:37:1427#include "crypto/nss_util.h"
28#include "crypto/rsa_private_key.h"
[email protected]f61c3972010-12-23 09:54:1529#include "net/base/address_list.h"
[email protected]bd707a62011-03-14 23:29:3430#include "net/base/cert_status_flags.h"
[email protected]f61c3972010-12-23 09:54:1531#include "net/base/cert_verifier.h"
32#include "net/base/host_port_pair.h"
33#include "net/base/io_buffer.h"
[email protected]e7f74da2011-04-19 23:49:3534#include "net/base/ip_endpoint.h"
[email protected]f61c3972010-12-23 09:54:1535#include "net/base/net_errors.h"
36#include "net/base/net_log.h"
37#include "net/base/ssl_config_service.h"
[email protected]4dc832e2011-04-28 22:04:2438#include "net/base/ssl_info.h"
[email protected]f61c3972010-12-23 09:54:1539#include "net/base/x509_certificate.h"
[email protected]f61c3972010-12-23 09:54:1540#include "net/socket/client_socket_factory.h"
41#include "net/socket/socket_test_util.h"
42#include "net/socket/ssl_client_socket.h"
[email protected]3268023f2011-05-05 00:08:1043#include "net/socket/stream_socket.h"
[email protected]f61c3972010-12-23 09:54:1544#include "testing/gtest/include/gtest/gtest.h"
45#include "testing/platform_test.h"
46
47namespace net {
48
49namespace {
50
51class FakeDataChannel {
52 public:
[email protected]55ee0e52011-07-21 18:29:4453 FakeDataChannel()
[email protected]3f55aa12011-12-07 02:03:3354 : old_read_callback_(NULL),
[email protected]55ee0e52011-07-21 18:29:4455 read_buf_len_(0),
56 ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
[email protected]f61c3972010-12-23 09:54:1557 }
58
59 virtual int Read(IOBuffer* buf, int buf_len,
[email protected]f1f3f0f82011-10-01 20:38:1060 OldCompletionCallback* callback) {
[email protected]f61c3972010-12-23 09:54:1561 if (data_.empty()) {
[email protected]3f55aa12011-12-07 02:03:3362 old_read_callback_ = callback;
63 read_buf_ = buf;
64 read_buf_len_ = buf_len;
65 return net::ERR_IO_PENDING;
66 }
67 return PropogateData(buf, buf_len);
68 }
69 virtual int Read(IOBuffer* buf, int buf_len,
70 const CompletionCallback& callback) {
71 if (data_.empty()) {
[email protected]f61c3972010-12-23 09:54:1572 read_callback_ = callback;
73 read_buf_ = buf;
74 read_buf_len_ = buf_len;
75 return net::ERR_IO_PENDING;
76 }
77 return PropogateData(buf, buf_len);
78 }
79
80 virtual int Write(IOBuffer* buf, int buf_len,
[email protected]f1f3f0f82011-10-01 20:38:1081 OldCompletionCallback* callback) {
[email protected]f61c3972010-12-23 09:54:1582 data_.push(new net::DrainableIOBuffer(buf, buf_len));
[email protected]55ee0e52011-07-21 18:29:4483 MessageLoop::current()->PostTask(
84 FROM_HERE, task_factory_.NewRunnableMethod(
85 &FakeDataChannel::DoReadCallback));
[email protected]f61c3972010-12-23 09:54:1586 return buf_len;
87 }
88
89 private:
90 void DoReadCallback() {
[email protected]3f55aa12011-12-07 02:03:3391 if ((!old_read_callback_ && read_callback_.is_null()) || data_.empty())
[email protected]f61c3972010-12-23 09:54:1592 return;
93
94 int copied = PropogateData(read_buf_, read_buf_len_);
[email protected]3f55aa12011-12-07 02:03:3395 if (old_read_callback_) {
96 net::OldCompletionCallback* callback = old_read_callback_;
97 old_read_callback_ = NULL;
98 read_buf_ = NULL;
99 read_buf_len_ = 0;
100 callback->Run(copied);
101 } else {
102 net::CompletionCallback callback = read_callback_;
103 read_callback_.Reset();
104 read_buf_ = NULL;
105 read_buf_len_ = 0;
106 callback.Run(copied);
107 }
[email protected]f61c3972010-12-23 09:54:15108 }
109
110 int PropogateData(scoped_refptr<net::IOBuffer> read_buf, int read_buf_len) {
111 scoped_refptr<net::DrainableIOBuffer> buf = data_.front();
112 int copied = std::min(buf->BytesRemaining(), read_buf_len);
113 memcpy(read_buf->data(), buf->data(), copied);
114 buf->DidConsume(copied);
115
116 if (!buf->BytesRemaining())
117 data_.pop();
118 return copied;
119 }
120
[email protected]3f55aa12011-12-07 02:03:33121 net::OldCompletionCallback* old_read_callback_;
122 net::CompletionCallback read_callback_;
[email protected]f61c3972010-12-23 09:54:15123 scoped_refptr<net::IOBuffer> read_buf_;
124 int read_buf_len_;
125
126 std::queue<scoped_refptr<net::DrainableIOBuffer> > data_;
127
[email protected]55ee0e52011-07-21 18:29:44128 ScopedRunnableMethodFactory<FakeDataChannel> task_factory_;
129
[email protected]f61c3972010-12-23 09:54:15130 DISALLOW_COPY_AND_ASSIGN(FakeDataChannel);
131};
132
[email protected]3268023f2011-05-05 00:08:10133class FakeSocket : public StreamSocket {
[email protected]f61c3972010-12-23 09:54:15134 public:
135 FakeSocket(FakeDataChannel* incoming_channel,
136 FakeDataChannel* outgoing_channel)
137 : incoming_(incoming_channel),
138 outgoing_(outgoing_channel) {
139 }
140
141 virtual ~FakeSocket() {
[email protected]f61c3972010-12-23 09:54:15142 }
143
144 virtual int Read(IOBuffer* buf, int buf_len,
[email protected]f1f3f0f82011-10-01 20:38:10145 OldCompletionCallback* callback) {
[email protected]55ee0e52011-07-21 18:29:44146 // Read random number of bytes.
147 buf_len = rand() % buf_len + 1;
[email protected]f61c3972010-12-23 09:54:15148 return incoming_->Read(buf, buf_len, callback);
149 }
[email protected]3f55aa12011-12-07 02:03:33150 virtual int Read(IOBuffer* buf, int buf_len,
151 const CompletionCallback& callback) {
152 // Read random number of bytes.
153 buf_len = rand() % buf_len + 1;
154 return incoming_->Read(buf, buf_len, callback);
155 }
[email protected]f61c3972010-12-23 09:54:15156
157 virtual int Write(IOBuffer* buf, int buf_len,
[email protected]f1f3f0f82011-10-01 20:38:10158 OldCompletionCallback* callback) {
[email protected]55ee0e52011-07-21 18:29:44159 // Write random number of bytes.
160 buf_len = rand() % buf_len + 1;
[email protected]f61c3972010-12-23 09:54:15161 return outgoing_->Write(buf, buf_len, callback);
162 }
163
164 virtual bool SetReceiveBufferSize(int32 size) {
165 return true;
166 }
167
168 virtual bool SetSendBufferSize(int32 size) {
169 return true;
170 }
171
[email protected]f1f3f0f82011-10-01 20:38:10172 virtual int Connect(OldCompletionCallback* callback) {
[email protected]f61c3972010-12-23 09:54:15173 return net::OK;
174 }
[email protected]dbf036f2011-12-06 23:33:24175 virtual int Connect(const CompletionCallback& callback) {
176 return net::OK;
177 }
[email protected]f61c3972010-12-23 09:54:15178
179 virtual void Disconnect() {}
180
181 virtual bool IsConnected() const {
182 return true;
183 }
184
185 virtual bool IsConnectedAndIdle() const {
186 return true;
187 }
188
189 virtual int GetPeerAddress(AddressList* address) const {
190 net::IPAddressNumber ip_address(4);
[email protected]fe89ea72011-05-12 02:02:40191 *address = net::AddressList::CreateFromIPAddress(ip_address, 0 /*port*/);
[email protected]f61c3972010-12-23 09:54:15192 return net::OK;
193 }
194
[email protected]e7f74da2011-04-19 23:49:35195 virtual int GetLocalAddress(IPEndPoint* address) const {
196 net::IPAddressNumber ip_address(4);
197 *address = net::IPEndPoint(ip_address, 0);
198 return net::OK;
199 }
200
[email protected]f61c3972010-12-23 09:54:15201 virtual const BoundNetLog& NetLog() const {
202 return net_log_;
203 }
204
205 virtual void SetSubresourceSpeculation() {}
206 virtual void SetOmniboxSpeculation() {}
207
208 virtual bool WasEverUsed() const {
209 return true;
210 }
211
212 virtual bool UsingTCPFastOpen() const {
213 return false;
214 }
215
[email protected]5e6efa52011-06-27 17:26:41216 virtual int64 NumBytesRead() const {
217 return -1;
218 }
219
220 virtual base::TimeDelta GetConnectTimeMicros() const {
221 return base::TimeDelta::FromMicroseconds(-1);
222 }
223
[email protected]f61c3972010-12-23 09:54:15224 private:
225 net::BoundNetLog net_log_;
226 FakeDataChannel* incoming_;
227 FakeDataChannel* outgoing_;
228
229 DISALLOW_COPY_AND_ASSIGN(FakeSocket);
230};
231
232} // namespace
233
234// Verify the correctness of the test helper classes first.
235TEST(FakeSocketTest, DataTransfer) {
236 // Establish channels between two sockets.
237 FakeDataChannel channel_1;
238 FakeDataChannel channel_2;
239 FakeSocket client(&channel_1, &channel_2);
240 FakeSocket server(&channel_2, &channel_1);
241
242 const char kTestData[] = "testing123";
243 const int kTestDataSize = strlen(kTestData);
244 const int kReadBufSize = 1024;
245 scoped_refptr<net::IOBuffer> write_buf = new net::StringIOBuffer(kTestData);
246 scoped_refptr<net::IOBuffer> read_buf = new net::IOBuffer(kReadBufSize);
247
248 // Write then read.
[email protected]55ee0e52011-07-21 18:29:44249 int written = server.Write(write_buf, kTestDataSize, NULL);
250 EXPECT_GT(written, 0);
251 EXPECT_LE(written, kTestDataSize);
252
253 int read = client.Read(read_buf, kReadBufSize, NULL);
254 EXPECT_GT(read, 0);
255 EXPECT_LE(read, written);
256 EXPECT_EQ(0, memcmp(kTestData, read_buf->data(), read));
[email protected]f61c3972010-12-23 09:54:15257
258 // Read then write.
[email protected]f1f3f0f82011-10-01 20:38:10259 TestOldCompletionCallback callback;
[email protected]f61c3972010-12-23 09:54:15260 EXPECT_EQ(net::ERR_IO_PENDING,
261 server.Read(read_buf, kReadBufSize, &callback));
[email protected]55ee0e52011-07-21 18:29:44262
263 written = client.Write(write_buf, kTestDataSize, NULL);
264 EXPECT_GT(written, 0);
265 EXPECT_LE(written, kTestDataSize);
266
267 read = callback.WaitForResult();
268 EXPECT_GT(read, 0);
269 EXPECT_LE(read, written);
270 EXPECT_EQ(0, memcmp(kTestData, read_buf->data(), read));
[email protected]f61c3972010-12-23 09:54:15271}
272
273class SSLServerSocketTest : public PlatformTest {
274 public:
275 SSLServerSocketTest()
276 : socket_factory_(net::ClientSocketFactory::GetDefaultFactory()) {
277 }
278
279 protected:
280 void Initialize() {
281 FakeSocket* fake_client_socket = new FakeSocket(&channel_1_, &channel_2_);
282 FakeSocket* fake_server_socket = new FakeSocket(&channel_2_, &channel_1_);
283
284 FilePath certs_dir;
285 PathService::Get(base::DIR_SOURCE_ROOT, &certs_dir);
286 certs_dir = certs_dir.AppendASCII("net");
287 certs_dir = certs_dir.AppendASCII("data");
288 certs_dir = certs_dir.AppendASCII("ssl");
289 certs_dir = certs_dir.AppendASCII("certificates");
290
291 FilePath cert_path = certs_dir.AppendASCII("unittest.selfsigned.der");
292 std::string cert_der;
293 ASSERT_TRUE(file_util::ReadFileToString(cert_path, &cert_der));
294
295 scoped_refptr<net::X509Certificate> cert =
296 X509Certificate::CreateFromBytes(cert_der.data(), cert_der.size());
297
298 FilePath key_path = certs_dir.AppendASCII("unittest.key.bin");
299 std::string key_string;
300 ASSERT_TRUE(file_util::ReadFileToString(key_path, &key_string));
301 std::vector<uint8> key_vector(
302 reinterpret_cast<const uint8*>(key_string.data()),
303 reinterpret_cast<const uint8*>(key_string.data() +
304 key_string.length()));
305
[email protected]4b559b4d2011-04-14 17:37:14306 scoped_ptr<crypto::RSAPrivateKey> private_key(
307 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
[email protected]f61c3972010-12-23 09:54:15308
309 net::SSLConfig ssl_config;
[email protected]2fb7e3ba2011-06-22 19:24:38310 ssl_config.cached_info_enabled = false;
[email protected]f61c3972010-12-23 09:54:15311 ssl_config.false_start_enabled = false;
[email protected]2619d3312011-07-20 23:50:34312 ssl_config.origin_bound_certs_enabled = false;
[email protected]f61c3972010-12-23 09:54:15313 ssl_config.ssl3_enabled = true;
314 ssl_config.tls1_enabled = true;
[email protected]f61c3972010-12-23 09:54:15315
316 // Certificate provided by the host doesn't need authority.
317 net::SSLConfig::CertAndStatus cert_and_status;
[email protected]4dc832e2011-04-28 22:04:24318 cert_and_status.cert_status = CERT_STATUS_AUTHORITY_INVALID;
[email protected]3d5c1bd2011-07-20 02:14:01319 cert_and_status.der_cert = cert_der;
[email protected]f61c3972010-12-23 09:54:15320 ssl_config.allowed_bad_certs.push_back(cert_and_status);
321
322 net::HostPortPair host_and_pair("unittest", 0);
[email protected]feb79bcd2011-07-21 16:55:17323 net::SSLClientSocketContext context;
324 context.cert_verifier = &cert_verifier_;
[email protected]f61c3972010-12-23 09:54:15325 client_socket_.reset(
326 socket_factory_->CreateSSLClientSocket(
[email protected]feb79bcd2011-07-21 16:55:17327 fake_client_socket, host_and_pair, ssl_config, NULL, context));
[email protected]f61c3972010-12-23 09:54:15328 server_socket_.reset(net::CreateSSLServerSocket(fake_server_socket,
329 cert, private_key.get(),
330 net::SSLConfig()));
331 }
332
333 FakeDataChannel channel_1_;
334 FakeDataChannel channel_2_;
335 scoped_ptr<net::SSLClientSocket> client_socket_;
336 scoped_ptr<net::SSLServerSocket> server_socket_;
337 net::ClientSocketFactory* socket_factory_;
338 net::CertVerifier cert_verifier_;
339};
340
341// SSLServerSocket is only implemented using NSS.
342#if defined(USE_NSS) || defined(OS_WIN) || defined(OS_MACOSX)
343
344// This test only executes creation of client and server sockets. This is to
345// test that creation of sockets doesn't crash and have minimal code to run
346// under valgrind in order to help debugging memory problems.
347TEST_F(SSLServerSocketTest, Initialize) {
348 Initialize();
349}
350
[email protected]a7ac3c32011-06-17 19:10:15351// This test executes Connect() on SSLClientSocket and Handshake() on
352// SSLServerSocket to make sure handshaking between the two sockets is
[email protected]f61c3972010-12-23 09:54:15353// completed successfully.
354TEST_F(SSLServerSocketTest, Handshake) {
355 Initialize();
356
[email protected]f1f3f0f82011-10-01 20:38:10357 TestOldCompletionCallback connect_callback;
358 TestOldCompletionCallback handshake_callback;
[email protected]f61c3972010-12-23 09:54:15359
[email protected]b0ff3f82011-07-23 05:12:39360 int server_ret = server_socket_->Handshake(&handshake_callback);
[email protected]f61c3972010-12-23 09:54:15361 EXPECT_TRUE(server_ret == net::OK || server_ret == net::ERR_IO_PENDING);
362
363 int client_ret = client_socket_->Connect(&connect_callback);
364 EXPECT_TRUE(client_ret == net::OK || client_ret == net::ERR_IO_PENDING);
365
366 if (client_ret == net::ERR_IO_PENDING) {
367 EXPECT_EQ(net::OK, connect_callback.WaitForResult());
368 }
369 if (server_ret == net::ERR_IO_PENDING) {
[email protected]b0ff3f82011-07-23 05:12:39370 EXPECT_EQ(net::OK, handshake_callback.WaitForResult());
[email protected]f61c3972010-12-23 09:54:15371 }
[email protected]4dc832e2011-04-28 22:04:24372
373 // Make sure the cert status is expected.
374 SSLInfo ssl_info;
375 client_socket_->GetSSLInfo(&ssl_info);
376 EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, ssl_info.cert_status);
[email protected]f61c3972010-12-23 09:54:15377}
378
379TEST_F(SSLServerSocketTest, DataTransfer) {
380 Initialize();
381
[email protected]f1f3f0f82011-10-01 20:38:10382 TestOldCompletionCallback connect_callback;
383 TestOldCompletionCallback handshake_callback;
[email protected]f61c3972010-12-23 09:54:15384
385 // Establish connection.
386 int client_ret = client_socket_->Connect(&connect_callback);
[email protected]302b6272011-01-19 01:27:22387 ASSERT_TRUE(client_ret == net::OK || client_ret == net::ERR_IO_PENDING);
[email protected]f61c3972010-12-23 09:54:15388
[email protected]b0ff3f82011-07-23 05:12:39389 int server_ret = server_socket_->Handshake(&handshake_callback);
[email protected]302b6272011-01-19 01:27:22390 ASSERT_TRUE(server_ret == net::OK || server_ret == net::ERR_IO_PENDING);
[email protected]f61c3972010-12-23 09:54:15391
[email protected]febbbb52011-08-17 04:59:23392 client_ret = connect_callback.GetResult(client_ret);
393 ASSERT_EQ(net::OK, client_ret);
394 server_ret = handshake_callback.GetResult(server_ret);
395 ASSERT_EQ(net::OK, server_ret);
[email protected]f61c3972010-12-23 09:54:15396
397 const int kReadBufSize = 1024;
398 scoped_refptr<net::StringIOBuffer> write_buf =
399 new net::StringIOBuffer("testing123");
[email protected]febbbb52011-08-17 04:59:23400 scoped_refptr<net::DrainableIOBuffer> read_buf =
401 new net::DrainableIOBuffer(new net::IOBuffer(kReadBufSize),
402 kReadBufSize);
[email protected]f61c3972010-12-23 09:54:15403
404 // Write then read.
[email protected]f1f3f0f82011-10-01 20:38:10405 TestOldCompletionCallback write_callback;
406 TestOldCompletionCallback read_callback;
[email protected]f61c3972010-12-23 09:54:15407 server_ret = server_socket_->Write(write_buf, write_buf->size(),
408 &write_callback);
409 EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
[email protected]febbbb52011-08-17 04:59:23410 client_ret = client_socket_->Read(read_buf, read_buf->BytesRemaining(),
411 &read_callback);
[email protected]f61c3972010-12-23 09:54:15412 EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
413
[email protected]febbbb52011-08-17 04:59:23414 server_ret = write_callback.GetResult(server_ret);
415 EXPECT_GT(server_ret, 0);
416 client_ret = read_callback.GetResult(client_ret);
417 ASSERT_GT(client_ret, 0);
418
419 read_buf->DidConsume(client_ret);
420 while (read_buf->BytesConsumed() < write_buf->size()) {
421 client_ret = client_socket_->Read(read_buf, read_buf->BytesRemaining(),
422 &read_callback);
423 EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
424 client_ret = read_callback.GetResult(client_ret);
425 ASSERT_GT(client_ret, 0);
426 read_buf->DidConsume(client_ret);
[email protected]f61c3972010-12-23 09:54:15427 }
[email protected]febbbb52011-08-17 04:59:23428 EXPECT_EQ(write_buf->size(), read_buf->BytesConsumed());
429 read_buf->SetOffset(0);
[email protected]f61c3972010-12-23 09:54:15430 EXPECT_EQ(0, memcmp(write_buf->data(), read_buf->data(), write_buf->size()));
431
432 // Read then write.
433 write_buf = new net::StringIOBuffer("hello123");
[email protected]febbbb52011-08-17 04:59:23434 server_ret = server_socket_->Read(read_buf, read_buf->BytesRemaining(),
435 &read_callback);
[email protected]f61c3972010-12-23 09:54:15436 EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
437 client_ret = client_socket_->Write(write_buf, write_buf->size(),
438 &write_callback);
439 EXPECT_TRUE(client_ret > 0 || client_ret == net::ERR_IO_PENDING);
440
[email protected]febbbb52011-08-17 04:59:23441 server_ret = read_callback.GetResult(server_ret);
442 ASSERT_GT(server_ret, 0);
443 client_ret = write_callback.GetResult(client_ret);
444 EXPECT_GT(client_ret, 0);
445
446 read_buf->DidConsume(server_ret);
447 while (read_buf->BytesConsumed() < write_buf->size()) {
448 server_ret = server_socket_->Read(read_buf, read_buf->BytesRemaining(),
449 &read_callback);
450 EXPECT_TRUE(server_ret > 0 || server_ret == net::ERR_IO_PENDING);
451 server_ret = read_callback.GetResult(server_ret);
452 ASSERT_GT(server_ret, 0);
453 read_buf->DidConsume(server_ret);
[email protected]f61c3972010-12-23 09:54:15454 }
[email protected]febbbb52011-08-17 04:59:23455 EXPECT_EQ(write_buf->size(), read_buf->BytesConsumed());
456 read_buf->SetOffset(0);
[email protected]f61c3972010-12-23 09:54:15457 EXPECT_EQ(0, memcmp(write_buf->data(), read_buf->data(), write_buf->size()));
458}
[email protected]b0ff3f82011-07-23 05:12:39459
460// This test executes ExportKeyingMaterial() on the client and server sockets,
461// after connecting them, and verifies that the results match.
462// This test will fail if False Start is enabled (see crbug.com/90208).
463TEST_F(SSLServerSocketTest, ExportKeyingMaterial) {
464 Initialize();
465
[email protected]f1f3f0f82011-10-01 20:38:10466 TestOldCompletionCallback connect_callback;
467 TestOldCompletionCallback handshake_callback;
[email protected]b0ff3f82011-07-23 05:12:39468
469 int client_ret = client_socket_->Connect(&connect_callback);
470 ASSERT_TRUE(client_ret == net::OK || client_ret == net::ERR_IO_PENDING);
471
472 int server_ret = server_socket_->Handshake(&handshake_callback);
473 ASSERT_TRUE(server_ret == net::OK || server_ret == net::ERR_IO_PENDING);
474
475 if (client_ret == net::ERR_IO_PENDING) {
476 ASSERT_EQ(net::OK, connect_callback.WaitForResult());
477 }
478 if (server_ret == net::ERR_IO_PENDING) {
479 ASSERT_EQ(net::OK, handshake_callback.WaitForResult());
480 }
481
482 const int kKeyingMaterialSize = 32;
483 const char* kKeyingLabel = "EXPERIMENTAL-server-socket-test";
484 const char* kKeyingContext = "";
485 unsigned char server_out[kKeyingMaterialSize];
486 int rv = server_socket_->ExportKeyingMaterial(kKeyingLabel, kKeyingContext,
487 server_out, sizeof(server_out));
488 ASSERT_EQ(rv, net::OK);
489
490 unsigned char client_out[kKeyingMaterialSize];
491 rv = client_socket_->ExportKeyingMaterial(kKeyingLabel, kKeyingContext,
492 client_out, sizeof(client_out));
493 ASSERT_EQ(rv, net::OK);
494 EXPECT_TRUE(memcmp(server_out, client_out, sizeof(server_out)) == 0);
495
496 const char* kKeyingLabelBad = "EXPERIMENTAL-server-socket-test-bad";
497 unsigned char client_bad[kKeyingMaterialSize];
498 rv = client_socket_->ExportKeyingMaterial(kKeyingLabelBad, kKeyingContext,
499 client_bad, sizeof(client_bad));
500 ASSERT_EQ(rv, net::OK);
501 EXPECT_TRUE(memcmp(server_out, client_bad, sizeof(server_out)) != 0);
502}
[email protected]f61c3972010-12-23 09:54:15503#endif
504
505} // namespace net