ssl_server_socket_unittest.cc 53 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411
  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. // This test suite uses SSLClientSocket to test the implementation of
  5. // SSLServerSocket. In order to establish connections between the sockets
  6. // we need two additional classes:
  7. // 1. FakeSocket
  8. // Connects SSL socket to FakeDataChannel. This class is just a stub.
  9. //
  10. // 2. FakeDataChannel
  11. // Implements the actual exchange of data between two FakeSockets.
  12. //
  13. // Implementations of these two classes are included in this file.
  14. #include "net/socket/ssl_server_socket.h"
  15. #include <stdint.h>
  16. #include <stdlib.h>
  17. #include <memory>
  18. #include <utility>
  19. #include "base/bind.h"
  20. #include "base/callback_helpers.h"
  21. #include "base/check.h"
  22. #include "base/compiler_specific.h"
  23. #include "base/containers/queue.h"
  24. #include "base/files/file_path.h"
  25. #include "base/files/file_util.h"
  26. #include "base/location.h"
  27. #include "base/memory/raw_ptr.h"
  28. #include "base/memory/scoped_refptr.h"
  29. #include "base/notreached.h"
  30. #include "base/run_loop.h"
  31. #include "base/task/single_thread_task_runner.h"
  32. #include "base/test/task_environment.h"
  33. #include "base/threading/thread_task_runner_handle.h"
  34. #include "build/build_config.h"
  35. #include "crypto/nss_util.h"
  36. #include "crypto/rsa_private_key.h"
  37. #include "crypto/signature_creator.h"
  38. #include "net/base/address_list.h"
  39. #include "net/base/completion_once_callback.h"
  40. #include "net/base/host_port_pair.h"
  41. #include "net/base/io_buffer.h"
  42. #include "net/base/ip_address.h"
  43. #include "net/base/ip_endpoint.h"
  44. #include "net/base/net_errors.h"
  45. #include "net/cert/cert_status_flags.h"
  46. #include "net/cert/ct_policy_enforcer.h"
  47. #include "net/cert/ct_policy_status.h"
  48. #include "net/cert/mock_cert_verifier.h"
  49. #include "net/cert/mock_client_cert_verifier.h"
  50. #include "net/cert/signed_certificate_timestamp_and_status.h"
  51. #include "net/cert/x509_certificate.h"
  52. #include "net/http/transport_security_state.h"
  53. #include "net/log/net_log_with_source.h"
  54. #include "net/socket/client_socket_factory.h"
  55. #include "net/socket/socket_test_util.h"
  56. #include "net/socket/ssl_client_socket.h"
  57. #include "net/socket/stream_socket.h"
  58. #include "net/ssl/ssl_cert_request_info.h"
  59. #include "net/ssl/ssl_cipher_suite_names.h"
  60. #include "net/ssl/ssl_client_session_cache.h"
  61. #include "net/ssl/ssl_connection_status_flags.h"
  62. #include "net/ssl/ssl_info.h"
  63. #include "net/ssl/ssl_private_key.h"
  64. #include "net/ssl/ssl_server_config.h"
  65. #include "net/ssl/test_ssl_config_service.h"
  66. #include "net/ssl/test_ssl_private_key.h"
  67. #include "net/test/cert_test_util.h"
  68. #include "net/test/gtest_util.h"
  69. #include "net/test/test_data_directory.h"
  70. #include "net/test/test_with_task_environment.h"
  71. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  72. #include "testing/gmock/include/gmock/gmock.h"
  73. #include "testing/gtest/include/gtest/gtest.h"
  74. #include "testing/platform_test.h"
  75. #include "third_party/boringssl/src/include/openssl/evp.h"
  76. #include "third_party/boringssl/src/include/openssl/ssl.h"
  77. using net::test::IsError;
  78. using net::test::IsOk;
  79. namespace net {
  80. namespace {
  81. const char kClientCertFileName[] = "client_1.pem";
  82. const char kClientPrivateKeyFileName[] = "client_1.pk8";
  83. const char kWrongClientCertFileName[] = "client_2.pem";
  84. const char kWrongClientPrivateKeyFileName[] = "client_2.pk8";
  85. class MockCTPolicyEnforcer : public CTPolicyEnforcer {
  86. public:
  87. MockCTPolicyEnforcer() = default;
  88. ~MockCTPolicyEnforcer() override = default;
  89. ct::CTPolicyCompliance CheckCompliance(
  90. X509Certificate* cert,
  91. const ct::SCTList& verified_scts,
  92. const NetLogWithSource& net_log) override {
  93. return ct::CTPolicyCompliance::CT_POLICY_COMPLIES_VIA_SCTS;
  94. }
  95. };
  96. class FakeDataChannel {
  97. public:
  98. FakeDataChannel() = default;
  99. FakeDataChannel(const FakeDataChannel&) = delete;
  100. FakeDataChannel& operator=(const FakeDataChannel&) = delete;
  101. int Read(IOBuffer* buf, int buf_len, CompletionOnceCallback callback) {
  102. DCHECK(read_callback_.is_null());
  103. DCHECK(!read_buf_.get());
  104. if (closed_)
  105. return 0;
  106. if (data_.empty()) {
  107. read_callback_ = std::move(callback);
  108. read_buf_ = buf;
  109. read_buf_len_ = buf_len;
  110. return ERR_IO_PENDING;
  111. }
  112. return PropagateData(buf, buf_len);
  113. }
  114. int Write(IOBuffer* buf,
  115. int buf_len,
  116. CompletionOnceCallback callback,
  117. const NetworkTrafficAnnotationTag& traffic_annotation) {
  118. DCHECK(write_callback_.is_null());
  119. if (closed_) {
  120. if (write_called_after_close_)
  121. return ERR_CONNECTION_RESET;
  122. write_called_after_close_ = true;
  123. write_callback_ = std::move(callback);
  124. base::ThreadTaskRunnerHandle::Get()->PostTask(
  125. FROM_HERE, base::BindOnce(&FakeDataChannel::DoWriteCallback,
  126. weak_factory_.GetWeakPtr()));
  127. return ERR_IO_PENDING;
  128. }
  129. // This function returns synchronously, so make a copy of the buffer.
  130. data_.push(base::MakeRefCounted<DrainableIOBuffer>(
  131. base::MakeRefCounted<StringIOBuffer>(std::string(buf->data(), buf_len)),
  132. buf_len));
  133. base::ThreadTaskRunnerHandle::Get()->PostTask(
  134. FROM_HERE, base::BindOnce(&FakeDataChannel::DoReadCallback,
  135. weak_factory_.GetWeakPtr()));
  136. return buf_len;
  137. }
  138. // Closes the FakeDataChannel. After Close() is called, Read() returns 0,
  139. // indicating EOF, and Write() fails with ERR_CONNECTION_RESET. Note that
  140. // after the FakeDataChannel is closed, the first Write() call completes
  141. // asynchronously, which is necessary to reproduce bug 127822.
  142. void Close() {
  143. closed_ = true;
  144. if (!read_callback_.is_null()) {
  145. base::ThreadTaskRunnerHandle::Get()->PostTask(
  146. FROM_HERE, base::BindOnce(&FakeDataChannel::DoReadCallback,
  147. weak_factory_.GetWeakPtr()));
  148. }
  149. }
  150. private:
  151. void DoReadCallback() {
  152. if (read_callback_.is_null())
  153. return;
  154. if (closed_) {
  155. std::move(read_callback_).Run(ERR_CONNECTION_CLOSED);
  156. return;
  157. }
  158. if (data_.empty())
  159. return;
  160. int copied = PropagateData(read_buf_, read_buf_len_);
  161. read_buf_ = nullptr;
  162. read_buf_len_ = 0;
  163. std::move(read_callback_).Run(copied);
  164. }
  165. void DoWriteCallback() {
  166. if (write_callback_.is_null())
  167. return;
  168. std::move(write_callback_).Run(ERR_CONNECTION_RESET);
  169. }
  170. int PropagateData(scoped_refptr<IOBuffer> read_buf, int read_buf_len) {
  171. scoped_refptr<DrainableIOBuffer> buf = data_.front();
  172. int copied = std::min(buf->BytesRemaining(), read_buf_len);
  173. memcpy(read_buf->data(), buf->data(), copied);
  174. buf->DidConsume(copied);
  175. if (!buf->BytesRemaining())
  176. data_.pop();
  177. return copied;
  178. }
  179. CompletionOnceCallback read_callback_;
  180. scoped_refptr<IOBuffer> read_buf_;
  181. int read_buf_len_ = 0;
  182. CompletionOnceCallback write_callback_;
  183. base::queue<scoped_refptr<DrainableIOBuffer>> data_;
  184. // True if Close() has been called.
  185. bool closed_ = false;
  186. // Controls the completion of Write() after the FakeDataChannel is closed.
  187. // After the FakeDataChannel is closed, the first Write() call completes
  188. // asynchronously.
  189. bool write_called_after_close_ = false;
  190. base::WeakPtrFactory<FakeDataChannel> weak_factory_{this};
  191. };
  192. class FakeSocket : public StreamSocket {
  193. public:
  194. FakeSocket(FakeDataChannel* incoming_channel,
  195. FakeDataChannel* outgoing_channel)
  196. : incoming_(incoming_channel), outgoing_(outgoing_channel) {}
  197. FakeSocket(const FakeSocket&) = delete;
  198. FakeSocket& operator=(const FakeSocket&) = delete;
  199. ~FakeSocket() override = default;
  200. int Read(IOBuffer* buf,
  201. int buf_len,
  202. CompletionOnceCallback callback) override {
  203. // Read random number of bytes.
  204. buf_len = rand() % buf_len + 1;
  205. return incoming_->Read(buf, buf_len, std::move(callback));
  206. }
  207. int Write(IOBuffer* buf,
  208. int buf_len,
  209. CompletionOnceCallback callback,
  210. const NetworkTrafficAnnotationTag& traffic_annotation) override {
  211. // Write random number of bytes.
  212. buf_len = rand() % buf_len + 1;
  213. return outgoing_->Write(buf, buf_len, std::move(callback),
  214. TRAFFIC_ANNOTATION_FOR_TESTS);
  215. }
  216. int SetReceiveBufferSize(int32_t size) override { return OK; }
  217. int SetSendBufferSize(int32_t size) override { return OK; }
  218. int Connect(CompletionOnceCallback callback) override { return OK; }
  219. void Disconnect() override {
  220. incoming_->Close();
  221. outgoing_->Close();
  222. }
  223. bool IsConnected() const override { return true; }
  224. bool IsConnectedAndIdle() const override { return true; }
  225. int GetPeerAddress(IPEndPoint* address) const override {
  226. *address = IPEndPoint(IPAddress::IPv4AllZeros(), 0 /*port*/);
  227. return OK;
  228. }
  229. int GetLocalAddress(IPEndPoint* address) const override {
  230. *address = IPEndPoint(IPAddress::IPv4AllZeros(), 0 /*port*/);
  231. return OK;
  232. }
  233. const NetLogWithSource& NetLog() const override { return net_log_; }
  234. bool WasEverUsed() const override { return true; }
  235. bool WasAlpnNegotiated() const override { return false; }
  236. NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
  237. bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
  238. int64_t GetTotalReceivedBytes() const override {
  239. NOTIMPLEMENTED();
  240. return 0;
  241. }
  242. void ApplySocketTag(const SocketTag& tag) override {}
  243. private:
  244. NetLogWithSource net_log_;
  245. raw_ptr<FakeDataChannel> incoming_;
  246. raw_ptr<FakeDataChannel> outgoing_;
  247. };
  248. } // namespace
  249. // Verify the correctness of the test helper classes first.
  250. TEST(FakeSocketTest, DataTransfer) {
  251. base::test::TaskEnvironment task_environment;
  252. // Establish channels between two sockets.
  253. FakeDataChannel channel_1;
  254. FakeDataChannel channel_2;
  255. FakeSocket client(&channel_1, &channel_2);
  256. FakeSocket server(&channel_2, &channel_1);
  257. const char kTestData[] = "testing123";
  258. const int kTestDataSize = strlen(kTestData);
  259. const int kReadBufSize = 1024;
  260. scoped_refptr<IOBuffer> write_buf =
  261. base::MakeRefCounted<StringIOBuffer>(kTestData);
  262. scoped_refptr<IOBuffer> read_buf =
  263. base::MakeRefCounted<IOBuffer>(kReadBufSize);
  264. // Write then read.
  265. int written =
  266. server.Write(write_buf.get(), kTestDataSize, CompletionOnceCallback(),
  267. TRAFFIC_ANNOTATION_FOR_TESTS);
  268. EXPECT_GT(written, 0);
  269. EXPECT_LE(written, kTestDataSize);
  270. int read =
  271. client.Read(read_buf.get(), kReadBufSize, CompletionOnceCallback());
  272. EXPECT_GT(read, 0);
  273. EXPECT_LE(read, written);
  274. EXPECT_EQ(0, memcmp(kTestData, read_buf->data(), read));
  275. // Read then write.
  276. TestCompletionCallback callback;
  277. EXPECT_EQ(ERR_IO_PENDING,
  278. server.Read(read_buf.get(), kReadBufSize, callback.callback()));
  279. written =
  280. client.Write(write_buf.get(), kTestDataSize, CompletionOnceCallback(),
  281. TRAFFIC_ANNOTATION_FOR_TESTS);
  282. EXPECT_GT(written, 0);
  283. EXPECT_LE(written, kTestDataSize);
  284. read = callback.WaitForResult();
  285. EXPECT_GT(read, 0);
  286. EXPECT_LE(read, written);
  287. EXPECT_EQ(0, memcmp(kTestData, read_buf->data(), read));
  288. }
  289. class SSLServerSocketTest : public PlatformTest, public WithTaskEnvironment {
  290. public:
  291. SSLServerSocketTest()
  292. : ssl_config_service_(
  293. std::make_unique<TestSSLConfigService>(SSLContextConfig())),
  294. cert_verifier_(std::make_unique<MockCertVerifier>()),
  295. client_cert_verifier_(std::make_unique<MockClientCertVerifier>()),
  296. transport_security_state_(std::make_unique<TransportSecurityState>()),
  297. ct_policy_enforcer_(std::make_unique<MockCTPolicyEnforcer>()),
  298. ssl_client_session_cache_(std::make_unique<SSLClientSessionCache>(
  299. SSLClientSessionCache::Config())) {}
  300. void SetUp() override {
  301. PlatformTest::SetUp();
  302. cert_verifier_->set_default_result(ERR_CERT_AUTHORITY_INVALID);
  303. client_cert_verifier_->set_default_result(ERR_CERT_AUTHORITY_INVALID);
  304. server_cert_ =
  305. ImportCertFromFile(GetTestCertsDirectory(), "unittest.selfsigned.der");
  306. ASSERT_TRUE(server_cert_);
  307. server_private_key_ = ReadTestKey("unittest.key.bin");
  308. ASSERT_TRUE(server_private_key_);
  309. std::unique_ptr<crypto::RSAPrivateKey> key =
  310. ReadTestKey("unittest.key.bin");
  311. ASSERT_TRUE(key);
  312. server_ssl_private_key_ = WrapOpenSSLPrivateKey(bssl::UpRef(key->key()));
  313. // Certificate provided by the host doesn't need authority.
  314. client_ssl_config_.allowed_bad_certs.emplace_back(
  315. server_cert_, CERT_STATUS_AUTHORITY_INVALID);
  316. client_context_ = std::make_unique<SSLClientContext>(
  317. ssl_config_service_.get(), cert_verifier_.get(),
  318. transport_security_state_.get(), ct_policy_enforcer_.get(),
  319. ssl_client_session_cache_.get(), nullptr);
  320. }
  321. protected:
  322. void CreateContext() {
  323. client_socket_.reset();
  324. server_socket_.reset();
  325. channel_1_.reset();
  326. channel_2_.reset();
  327. server_context_ = CreateSSLServerContext(
  328. server_cert_.get(), *server_private_key_, server_ssl_config_);
  329. }
  330. void CreateContextSSLPrivateKey() {
  331. client_socket_.reset();
  332. server_socket_.reset();
  333. channel_1_.reset();
  334. channel_2_.reset();
  335. server_context_.reset();
  336. server_context_ = CreateSSLServerContext(
  337. server_cert_.get(), server_ssl_private_key_, server_ssl_config_);
  338. }
  339. static HostPortPair GetHostAndPort() { return HostPortPair("unittest", 0); }
  340. void CreateSockets() {
  341. client_socket_.reset();
  342. server_socket_.reset();
  343. channel_1_ = std::make_unique<FakeDataChannel>();
  344. channel_2_ = std::make_unique<FakeDataChannel>();
  345. std::unique_ptr<StreamSocket> client_connection =
  346. std::make_unique<FakeSocket>(channel_1_.get(), channel_2_.get());
  347. std::unique_ptr<StreamSocket> server_socket =
  348. std::make_unique<FakeSocket>(channel_2_.get(), channel_1_.get());
  349. client_socket_ = client_context_->CreateSSLClientSocket(
  350. std::move(client_connection), GetHostAndPort(), client_ssl_config_);
  351. ASSERT_TRUE(client_socket_);
  352. server_socket_ =
  353. server_context_->CreateSSLServerSocket(std::move(server_socket));
  354. ASSERT_TRUE(server_socket_);
  355. }
  356. void ConfigureClientCertsForClient(const char* cert_file_name,
  357. const char* private_key_file_name) {
  358. scoped_refptr<X509Certificate> client_cert =
  359. ImportCertFromFile(GetTestCertsDirectory(), cert_file_name);
  360. ASSERT_TRUE(client_cert);
  361. std::unique_ptr<crypto::RSAPrivateKey> key =
  362. ReadTestKey(private_key_file_name);
  363. ASSERT_TRUE(key);
  364. client_context_->SetClientCertificate(
  365. GetHostAndPort(), std::move(client_cert),
  366. WrapOpenSSLPrivateKey(bssl::UpRef(key->key())));
  367. }
  368. void ConfigureClientCertsForServer() {
  369. server_ssl_config_.client_cert_type =
  370. SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
  371. // "CN=B CA" - DER encoded DN of the issuer of client_1.pem
  372. static const uint8_t kClientCertCAName[] = {
  373. 0x30, 0x0f, 0x31, 0x0d, 0x30, 0x0b, 0x06, 0x03, 0x55,
  374. 0x04, 0x03, 0x0c, 0x04, 0x42, 0x20, 0x43, 0x41};
  375. server_ssl_config_.cert_authorities.emplace_back(
  376. std::begin(kClientCertCAName), std::end(kClientCertCAName));
  377. scoped_refptr<X509Certificate> expected_client_cert(
  378. ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName));
  379. ASSERT_TRUE(expected_client_cert);
  380. client_cert_verifier_->AddResultForCert(expected_client_cert.get(), OK);
  381. server_ssl_config_.client_cert_verifier = client_cert_verifier_.get();
  382. }
  383. std::unique_ptr<crypto::RSAPrivateKey> ReadTestKey(
  384. const base::StringPiece& name) {
  385. base::FilePath certs_dir(GetTestCertsDirectory());
  386. base::FilePath key_path = certs_dir.AppendASCII(name);
  387. std::string key_string;
  388. if (!base::ReadFileToString(key_path, &key_string))
  389. return nullptr;
  390. std::vector<uint8_t> key_vector(
  391. reinterpret_cast<const uint8_t*>(key_string.data()),
  392. reinterpret_cast<const uint8_t*>(key_string.data() +
  393. key_string.length()));
  394. std::unique_ptr<crypto::RSAPrivateKey> key(
  395. crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
  396. return key;
  397. }
  398. void PumpServerToClient() {
  399. const int kReadBufSize = 1024;
  400. scoped_refptr<StringIOBuffer> write_buf =
  401. base::MakeRefCounted<StringIOBuffer>("testing123");
  402. scoped_refptr<DrainableIOBuffer> read_buf =
  403. base::MakeRefCounted<DrainableIOBuffer>(
  404. base::MakeRefCounted<IOBuffer>(kReadBufSize), kReadBufSize);
  405. TestCompletionCallback write_callback;
  406. TestCompletionCallback read_callback;
  407. int server_ret = server_socket_->Write(write_buf.get(), write_buf->size(),
  408. write_callback.callback(),
  409. TRAFFIC_ANNOTATION_FOR_TESTS);
  410. EXPECT_TRUE(server_ret > 0 || server_ret == ERR_IO_PENDING);
  411. int client_ret = client_socket_->Read(
  412. read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
  413. EXPECT_TRUE(client_ret > 0 || client_ret == ERR_IO_PENDING);
  414. 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. std::unique_ptr<FakeDataChannel> channel_1_;
  420. std::unique_ptr<FakeDataChannel> channel_2_;
  421. SSLConfig client_ssl_config_;
  422. SSLServerConfig server_ssl_config_;
  423. std::unique_ptr<TestSSLConfigService> ssl_config_service_;
  424. std::unique_ptr<MockCertVerifier> cert_verifier_;
  425. std::unique_ptr<MockClientCertVerifier> client_cert_verifier_;
  426. std::unique_ptr<TransportSecurityState> transport_security_state_;
  427. std::unique_ptr<MockCTPolicyEnforcer> ct_policy_enforcer_;
  428. std::unique_ptr<SSLClientSessionCache> ssl_client_session_cache_;
  429. std::unique_ptr<SSLClientContext> client_context_;
  430. std::unique_ptr<SSLServerContext> server_context_;
  431. std::unique_ptr<SSLClientSocket> client_socket_;
  432. std::unique_ptr<SSLServerSocket> server_socket_;
  433. std::unique_ptr<crypto::RSAPrivateKey> server_private_key_;
  434. scoped_refptr<SSLPrivateKey> server_ssl_private_key_;
  435. scoped_refptr<X509Certificate> server_cert_;
  436. };
  437. class SSLServerSocketReadTest : public SSLServerSocketTest,
  438. public ::testing::WithParamInterface<bool> {
  439. protected:
  440. SSLServerSocketReadTest() : read_if_ready_enabled_(GetParam()) {}
  441. int Read(StreamSocket* socket,
  442. IOBuffer* buf,
  443. int buf_len,
  444. CompletionOnceCallback callback) {
  445. if (read_if_ready_enabled()) {
  446. return socket->ReadIfReady(buf, buf_len, std::move(callback));
  447. }
  448. return socket->Read(buf, buf_len, std::move(callback));
  449. }
  450. bool read_if_ready_enabled() const { return read_if_ready_enabled_; }
  451. private:
  452. const bool read_if_ready_enabled_;
  453. };
  454. INSTANTIATE_TEST_SUITE_P(/* no prefix */,
  455. SSLServerSocketReadTest,
  456. ::testing::Bool());
  457. // This test only executes creation of client and server sockets. This is to
  458. // test that creation of sockets doesn't crash and have minimal code to run
  459. // with memory leak/corruption checking tools.
  460. TEST_F(SSLServerSocketTest, Initialize) {
  461. ASSERT_NO_FATAL_FAILURE(CreateContext());
  462. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  463. }
  464. // This test executes Connect() on SSLClientSocket and Handshake() on
  465. // SSLServerSocket to make sure handshaking between the two sockets is
  466. // completed successfully.
  467. TEST_F(SSLServerSocketTest, Handshake) {
  468. ASSERT_NO_FATAL_FAILURE(CreateContext());
  469. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  470. TestCompletionCallback handshake_callback;
  471. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  472. TestCompletionCallback connect_callback;
  473. int client_ret = client_socket_->Connect(connect_callback.callback());
  474. client_ret = connect_callback.GetResult(client_ret);
  475. server_ret = handshake_callback.GetResult(server_ret);
  476. ASSERT_THAT(client_ret, IsOk());
  477. ASSERT_THAT(server_ret, IsOk());
  478. // Make sure the cert status is expected.
  479. SSLInfo ssl_info;
  480. ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info));
  481. EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, ssl_info.cert_status);
  482. // The default cipher suite should be ECDHE and an AEAD.
  483. uint16_t cipher_suite =
  484. SSLConnectionStatusToCipherSuite(ssl_info.connection_status);
  485. const char* key_exchange;
  486. const char* cipher;
  487. const char* mac;
  488. bool is_aead;
  489. bool is_tls13;
  490. SSLCipherSuiteToStrings(&key_exchange, &cipher, &mac, &is_aead, &is_tls13,
  491. cipher_suite);
  492. EXPECT_TRUE(is_aead);
  493. }
  494. // This test makes sure the session cache is working.
  495. TEST_F(SSLServerSocketTest, HandshakeCached) {
  496. ASSERT_NO_FATAL_FAILURE(CreateContext());
  497. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  498. TestCompletionCallback handshake_callback;
  499. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  500. TestCompletionCallback connect_callback;
  501. int client_ret = client_socket_->Connect(connect_callback.callback());
  502. client_ret = connect_callback.GetResult(client_ret);
  503. server_ret = handshake_callback.GetResult(server_ret);
  504. ASSERT_THAT(client_ret, IsOk());
  505. ASSERT_THAT(server_ret, IsOk());
  506. // Make sure the cert status is expected.
  507. SSLInfo ssl_info;
  508. ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info));
  509. EXPECT_EQ(ssl_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
  510. SSLInfo ssl_server_info;
  511. ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info));
  512. EXPECT_EQ(ssl_server_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
  513. // Pump client read to get new session tickets.
  514. PumpServerToClient();
  515. // Make sure the second connection is cached.
  516. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  517. TestCompletionCallback handshake_callback2;
  518. int server_ret2 = server_socket_->Handshake(handshake_callback2.callback());
  519. TestCompletionCallback connect_callback2;
  520. int client_ret2 = client_socket_->Connect(connect_callback2.callback());
  521. client_ret2 = connect_callback2.GetResult(client_ret2);
  522. server_ret2 = handshake_callback2.GetResult(server_ret2);
  523. ASSERT_THAT(client_ret2, IsOk());
  524. ASSERT_THAT(server_ret2, IsOk());
  525. // Make sure the cert status is expected.
  526. SSLInfo ssl_info2;
  527. ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info2));
  528. EXPECT_EQ(ssl_info2.handshake_type, SSLInfo::HANDSHAKE_RESUME);
  529. SSLInfo ssl_server_info2;
  530. ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info2));
  531. EXPECT_EQ(ssl_server_info2.handshake_type, SSLInfo::HANDSHAKE_RESUME);
  532. }
  533. // This test makes sure the session cache separates out by server context.
  534. TEST_F(SSLServerSocketTest, HandshakeCachedContextSwitch) {
  535. ASSERT_NO_FATAL_FAILURE(CreateContext());
  536. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  537. TestCompletionCallback handshake_callback;
  538. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  539. TestCompletionCallback connect_callback;
  540. int client_ret = client_socket_->Connect(connect_callback.callback());
  541. client_ret = connect_callback.GetResult(client_ret);
  542. server_ret = handshake_callback.GetResult(server_ret);
  543. ASSERT_THAT(client_ret, IsOk());
  544. ASSERT_THAT(server_ret, IsOk());
  545. // Make sure the cert status is expected.
  546. SSLInfo ssl_info;
  547. ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info));
  548. EXPECT_EQ(ssl_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
  549. SSLInfo ssl_server_info;
  550. ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info));
  551. EXPECT_EQ(ssl_server_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
  552. // Make sure the second connection is NOT cached when using a new context.
  553. ASSERT_NO_FATAL_FAILURE(CreateContext());
  554. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  555. TestCompletionCallback handshake_callback2;
  556. int server_ret2 = server_socket_->Handshake(handshake_callback2.callback());
  557. TestCompletionCallback connect_callback2;
  558. int client_ret2 = client_socket_->Connect(connect_callback2.callback());
  559. client_ret2 = connect_callback2.GetResult(client_ret2);
  560. server_ret2 = handshake_callback2.GetResult(server_ret2);
  561. ASSERT_THAT(client_ret2, IsOk());
  562. ASSERT_THAT(server_ret2, IsOk());
  563. // Make sure the cert status is expected.
  564. SSLInfo ssl_info2;
  565. ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info2));
  566. EXPECT_EQ(ssl_info2.handshake_type, SSLInfo::HANDSHAKE_FULL);
  567. SSLInfo ssl_server_info2;
  568. ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info2));
  569. EXPECT_EQ(ssl_server_info2.handshake_type, SSLInfo::HANDSHAKE_FULL);
  570. }
  571. // This test executes Connect() on SSLClientSocket and Handshake() on
  572. // SSLServerSocket to make sure handshaking between the two sockets is
  573. // completed successfully, using client certificate.
  574. TEST_F(SSLServerSocketTest, HandshakeWithClientCert) {
  575. scoped_refptr<X509Certificate> client_cert =
  576. ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
  577. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForClient(
  578. kClientCertFileName, kClientPrivateKeyFileName));
  579. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForServer());
  580. ASSERT_NO_FATAL_FAILURE(CreateContext());
  581. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  582. TestCompletionCallback handshake_callback;
  583. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  584. TestCompletionCallback connect_callback;
  585. int client_ret = client_socket_->Connect(connect_callback.callback());
  586. client_ret = connect_callback.GetResult(client_ret);
  587. server_ret = handshake_callback.GetResult(server_ret);
  588. ASSERT_THAT(client_ret, IsOk());
  589. ASSERT_THAT(server_ret, IsOk());
  590. // Make sure the cert status is expected.
  591. SSLInfo ssl_info;
  592. client_socket_->GetSSLInfo(&ssl_info);
  593. EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, ssl_info.cert_status);
  594. server_socket_->GetSSLInfo(&ssl_info);
  595. ASSERT_TRUE(ssl_info.cert.get());
  596. EXPECT_TRUE(client_cert->EqualsExcludingChain(ssl_info.cert.get()));
  597. }
  598. // This test executes Connect() on SSLClientSocket and Handshake() twice on
  599. // SSLServerSocket to make sure handshaking between the two sockets is
  600. // completed successfully, using client certificate. The second connection is
  601. // expected to succeed through the session cache.
  602. TEST_F(SSLServerSocketTest, HandshakeWithClientCertCached) {
  603. scoped_refptr<X509Certificate> client_cert =
  604. ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
  605. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForClient(
  606. kClientCertFileName, kClientPrivateKeyFileName));
  607. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForServer());
  608. ASSERT_NO_FATAL_FAILURE(CreateContext());
  609. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  610. TestCompletionCallback handshake_callback;
  611. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  612. TestCompletionCallback connect_callback;
  613. int client_ret = client_socket_->Connect(connect_callback.callback());
  614. client_ret = connect_callback.GetResult(client_ret);
  615. server_ret = handshake_callback.GetResult(server_ret);
  616. ASSERT_THAT(client_ret, IsOk());
  617. ASSERT_THAT(server_ret, IsOk());
  618. // Make sure the cert status is expected.
  619. SSLInfo ssl_info;
  620. ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info));
  621. EXPECT_EQ(ssl_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
  622. SSLInfo ssl_server_info;
  623. ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info));
  624. ASSERT_TRUE(ssl_server_info.cert.get());
  625. EXPECT_TRUE(client_cert->EqualsExcludingChain(ssl_server_info.cert.get()));
  626. EXPECT_EQ(ssl_server_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
  627. // Pump client read to get new session tickets.
  628. PumpServerToClient();
  629. server_socket_->Disconnect();
  630. client_socket_->Disconnect();
  631. // Create the connection again.
  632. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  633. TestCompletionCallback handshake_callback2;
  634. int server_ret2 = server_socket_->Handshake(handshake_callback2.callback());
  635. TestCompletionCallback connect_callback2;
  636. int client_ret2 = client_socket_->Connect(connect_callback2.callback());
  637. client_ret2 = connect_callback2.GetResult(client_ret2);
  638. server_ret2 = handshake_callback2.GetResult(server_ret2);
  639. ASSERT_THAT(client_ret2, IsOk());
  640. ASSERT_THAT(server_ret2, IsOk());
  641. // Make sure the cert status is expected.
  642. SSLInfo ssl_info2;
  643. ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info2));
  644. EXPECT_EQ(ssl_info2.handshake_type, SSLInfo::HANDSHAKE_RESUME);
  645. SSLInfo ssl_server_info2;
  646. ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info2));
  647. ASSERT_TRUE(ssl_server_info2.cert.get());
  648. EXPECT_TRUE(client_cert->EqualsExcludingChain(ssl_server_info2.cert.get()));
  649. EXPECT_EQ(ssl_server_info2.handshake_type, SSLInfo::HANDSHAKE_RESUME);
  650. }
  651. TEST_F(SSLServerSocketTest, HandshakeWithClientCertRequiredNotSupplied) {
  652. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForServer());
  653. ASSERT_NO_FATAL_FAILURE(CreateContext());
  654. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  655. // Use the default setting for the client socket, which is to not send
  656. // a client certificate. This will cause the client to receive an
  657. // ERR_SSL_CLIENT_AUTH_CERT_NEEDED error, and allow for inspecting the
  658. // requested cert_authorities from the CertificateRequest sent by the
  659. // server.
  660. TestCompletionCallback handshake_callback;
  661. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  662. TestCompletionCallback connect_callback;
  663. EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED,
  664. connect_callback.GetResult(
  665. client_socket_->Connect(connect_callback.callback())));
  666. auto request_info = base::MakeRefCounted<SSLCertRequestInfo>();
  667. client_socket_->GetSSLCertRequestInfo(request_info.get());
  668. // Check that the authority name that arrived in the CertificateRequest
  669. // handshake message is as expected.
  670. scoped_refptr<X509Certificate> client_cert =
  671. ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
  672. ASSERT_TRUE(client_cert);
  673. EXPECT_TRUE(client_cert->IsIssuedByEncoded(request_info->cert_authorities));
  674. client_socket_->Disconnect();
  675. EXPECT_THAT(handshake_callback.GetResult(server_ret),
  676. IsError(ERR_CONNECTION_CLOSED));
  677. }
  678. TEST_F(SSLServerSocketTest, HandshakeWithClientCertRequiredNotSuppliedCached) {
  679. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForServer());
  680. ASSERT_NO_FATAL_FAILURE(CreateContext());
  681. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  682. // Use the default setting for the client socket, which is to not send
  683. // a client certificate. This will cause the client to receive an
  684. // ERR_SSL_CLIENT_AUTH_CERT_NEEDED error, and allow for inspecting the
  685. // requested cert_authorities from the CertificateRequest sent by the
  686. // server.
  687. TestCompletionCallback handshake_callback;
  688. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  689. TestCompletionCallback connect_callback;
  690. EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED,
  691. connect_callback.GetResult(
  692. client_socket_->Connect(connect_callback.callback())));
  693. auto request_info = base::MakeRefCounted<SSLCertRequestInfo>();
  694. client_socket_->GetSSLCertRequestInfo(request_info.get());
  695. // Check that the authority name that arrived in the CertificateRequest
  696. // handshake message is as expected.
  697. scoped_refptr<X509Certificate> client_cert =
  698. ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
  699. ASSERT_TRUE(client_cert);
  700. EXPECT_TRUE(client_cert->IsIssuedByEncoded(request_info->cert_authorities));
  701. client_socket_->Disconnect();
  702. EXPECT_THAT(handshake_callback.GetResult(server_ret),
  703. IsError(ERR_CONNECTION_CLOSED));
  704. server_socket_->Disconnect();
  705. // Below, check that the cache didn't store the result of a failed handshake.
  706. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  707. TestCompletionCallback handshake_callback2;
  708. int server_ret2 = server_socket_->Handshake(handshake_callback2.callback());
  709. TestCompletionCallback connect_callback2;
  710. EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED,
  711. connect_callback2.GetResult(
  712. client_socket_->Connect(connect_callback2.callback())));
  713. auto request_info2 = base::MakeRefCounted<SSLCertRequestInfo>();
  714. client_socket_->GetSSLCertRequestInfo(request_info2.get());
  715. // Check that the authority name that arrived in the CertificateRequest
  716. // handshake message is as expected.
  717. EXPECT_TRUE(client_cert->IsIssuedByEncoded(request_info2->cert_authorities));
  718. client_socket_->Disconnect();
  719. EXPECT_THAT(handshake_callback2.GetResult(server_ret2),
  720. IsError(ERR_CONNECTION_CLOSED));
  721. }
  722. TEST_F(SSLServerSocketTest, HandshakeWithWrongClientCertSupplied) {
  723. scoped_refptr<X509Certificate> client_cert =
  724. ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
  725. ASSERT_TRUE(client_cert);
  726. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForClient(
  727. kWrongClientCertFileName, kWrongClientPrivateKeyFileName));
  728. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForServer());
  729. ASSERT_NO_FATAL_FAILURE(CreateContext());
  730. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  731. TestCompletionCallback handshake_callback;
  732. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  733. TestCompletionCallback connect_callback;
  734. int client_ret = client_socket_->Connect(connect_callback.callback());
  735. // In TLS 1.3, the client cert error isn't exposed until Read is called.
  736. EXPECT_EQ(OK, connect_callback.GetResult(client_ret));
  737. EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT,
  738. handshake_callback.GetResult(server_ret));
  739. // Pump client read to get client cert error.
  740. const int kReadBufSize = 1024;
  741. scoped_refptr<DrainableIOBuffer> read_buf =
  742. base::MakeRefCounted<DrainableIOBuffer>(
  743. base::MakeRefCounted<IOBuffer>(kReadBufSize), kReadBufSize);
  744. TestCompletionCallback read_callback;
  745. client_ret = client_socket_->Read(read_buf.get(), read_buf->BytesRemaining(),
  746. read_callback.callback());
  747. client_ret = read_callback.GetResult(client_ret);
  748. EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT, client_ret);
  749. }
  750. TEST_F(SSLServerSocketTest, HandshakeWithWrongClientCertSuppliedTLS12) {
  751. scoped_refptr<X509Certificate> client_cert =
  752. ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
  753. ASSERT_TRUE(client_cert);
  754. client_ssl_config_.version_max_override = SSL_PROTOCOL_VERSION_TLS1_2;
  755. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForClient(
  756. kWrongClientCertFileName, kWrongClientPrivateKeyFileName));
  757. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForServer());
  758. ASSERT_NO_FATAL_FAILURE(CreateContext());
  759. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  760. TestCompletionCallback handshake_callback;
  761. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  762. TestCompletionCallback connect_callback;
  763. int client_ret = client_socket_->Connect(connect_callback.callback());
  764. EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT,
  765. connect_callback.GetResult(client_ret));
  766. EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT,
  767. handshake_callback.GetResult(server_ret));
  768. }
  769. TEST_F(SSLServerSocketTest, HandshakeWithWrongClientCertSuppliedCached) {
  770. scoped_refptr<X509Certificate> client_cert =
  771. ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
  772. ASSERT_TRUE(client_cert);
  773. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForClient(
  774. kWrongClientCertFileName, kWrongClientPrivateKeyFileName));
  775. ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForServer());
  776. ASSERT_NO_FATAL_FAILURE(CreateContext());
  777. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  778. TestCompletionCallback handshake_callback;
  779. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  780. TestCompletionCallback connect_callback;
  781. int client_ret = client_socket_->Connect(connect_callback.callback());
  782. // In TLS 1.3, the client cert error isn't exposed until Read is called.
  783. EXPECT_EQ(OK, connect_callback.GetResult(client_ret));
  784. EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT,
  785. handshake_callback.GetResult(server_ret));
  786. // Pump client read to get client cert error.
  787. const int kReadBufSize = 1024;
  788. scoped_refptr<DrainableIOBuffer> read_buf =
  789. base::MakeRefCounted<DrainableIOBuffer>(
  790. base::MakeRefCounted<IOBuffer>(kReadBufSize), kReadBufSize);
  791. TestCompletionCallback read_callback;
  792. client_ret = client_socket_->Read(read_buf.get(), read_buf->BytesRemaining(),
  793. read_callback.callback());
  794. client_ret = read_callback.GetResult(client_ret);
  795. EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT, client_ret);
  796. client_socket_->Disconnect();
  797. server_socket_->Disconnect();
  798. // Below, check that the cache didn't store the result of a failed handshake.
  799. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  800. TestCompletionCallback handshake_callback2;
  801. int server_ret2 = server_socket_->Handshake(handshake_callback2.callback());
  802. TestCompletionCallback connect_callback2;
  803. int client_ret2 = client_socket_->Connect(connect_callback2.callback());
  804. // In TLS 1.3, the client cert error isn't exposed until Read is called.
  805. EXPECT_EQ(OK, connect_callback2.GetResult(client_ret2));
  806. EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT,
  807. handshake_callback2.GetResult(server_ret2));
  808. // Pump client read to get client cert error.
  809. client_ret = client_socket_->Read(read_buf.get(), read_buf->BytesRemaining(),
  810. read_callback.callback());
  811. client_ret = read_callback.GetResult(client_ret);
  812. EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT, client_ret);
  813. }
  814. TEST_P(SSLServerSocketReadTest, DataTransfer) {
  815. ASSERT_NO_FATAL_FAILURE(CreateContext());
  816. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  817. // Establish connection.
  818. TestCompletionCallback connect_callback;
  819. int client_ret = client_socket_->Connect(connect_callback.callback());
  820. ASSERT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
  821. TestCompletionCallback handshake_callback;
  822. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  823. ASSERT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
  824. client_ret = connect_callback.GetResult(client_ret);
  825. ASSERT_THAT(client_ret, IsOk());
  826. server_ret = handshake_callback.GetResult(server_ret);
  827. ASSERT_THAT(server_ret, IsOk());
  828. const int kReadBufSize = 1024;
  829. scoped_refptr<StringIOBuffer> write_buf =
  830. base::MakeRefCounted<StringIOBuffer>("testing123");
  831. scoped_refptr<DrainableIOBuffer> read_buf =
  832. base::MakeRefCounted<DrainableIOBuffer>(
  833. base::MakeRefCounted<IOBuffer>(kReadBufSize), kReadBufSize);
  834. // Write then read.
  835. TestCompletionCallback write_callback;
  836. TestCompletionCallback read_callback;
  837. server_ret = server_socket_->Write(write_buf.get(), write_buf->size(),
  838. write_callback.callback(),
  839. TRAFFIC_ANNOTATION_FOR_TESTS);
  840. EXPECT_TRUE(server_ret > 0 || server_ret == ERR_IO_PENDING);
  841. client_ret = client_socket_->Read(
  842. read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
  843. EXPECT_TRUE(client_ret > 0 || client_ret == ERR_IO_PENDING);
  844. server_ret = write_callback.GetResult(server_ret);
  845. EXPECT_GT(server_ret, 0);
  846. client_ret = read_callback.GetResult(client_ret);
  847. ASSERT_GT(client_ret, 0);
  848. read_buf->DidConsume(client_ret);
  849. while (read_buf->BytesConsumed() < write_buf->size()) {
  850. client_ret = client_socket_->Read(
  851. read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
  852. EXPECT_TRUE(client_ret > 0 || client_ret == ERR_IO_PENDING);
  853. client_ret = read_callback.GetResult(client_ret);
  854. ASSERT_GT(client_ret, 0);
  855. read_buf->DidConsume(client_ret);
  856. }
  857. EXPECT_EQ(write_buf->size(), read_buf->BytesConsumed());
  858. read_buf->SetOffset(0);
  859. EXPECT_EQ(0, memcmp(write_buf->data(), read_buf->data(), write_buf->size()));
  860. // Read then write.
  861. write_buf = base::MakeRefCounted<StringIOBuffer>("hello123");
  862. server_ret = Read(server_socket_.get(), read_buf.get(),
  863. read_buf->BytesRemaining(), read_callback.callback());
  864. EXPECT_EQ(server_ret, ERR_IO_PENDING);
  865. client_ret = client_socket_->Write(write_buf.get(), write_buf->size(),
  866. write_callback.callback(),
  867. TRAFFIC_ANNOTATION_FOR_TESTS);
  868. EXPECT_TRUE(client_ret > 0 || client_ret == ERR_IO_PENDING);
  869. server_ret = read_callback.GetResult(server_ret);
  870. if (read_if_ready_enabled()) {
  871. // ReadIfReady signals the data is available but does not consume it.
  872. // The data is consumed later below.
  873. ASSERT_EQ(server_ret, OK);
  874. } else {
  875. ASSERT_GT(server_ret, 0);
  876. read_buf->DidConsume(server_ret);
  877. }
  878. client_ret = write_callback.GetResult(client_ret);
  879. EXPECT_GT(client_ret, 0);
  880. while (read_buf->BytesConsumed() < write_buf->size()) {
  881. server_ret = Read(server_socket_.get(), read_buf.get(),
  882. read_buf->BytesRemaining(), read_callback.callback());
  883. // All the data was written above, so the data should be synchronously
  884. // available out of both Read() and ReadIfReady().
  885. ASSERT_GT(server_ret, 0);
  886. read_buf->DidConsume(server_ret);
  887. }
  888. EXPECT_EQ(write_buf->size(), read_buf->BytesConsumed());
  889. read_buf->SetOffset(0);
  890. EXPECT_EQ(0, memcmp(write_buf->data(), read_buf->data(), write_buf->size()));
  891. }
  892. // A regression test for bug 127822 (http://crbug.com/127822).
  893. // If the server closes the connection after the handshake is finished,
  894. // the client's Write() call should not cause an infinite loop.
  895. // NOTE: this is a test for SSLClientSocket rather than SSLServerSocket.
  896. TEST_F(SSLServerSocketTest, ClientWriteAfterServerClose) {
  897. ASSERT_NO_FATAL_FAILURE(CreateContext());
  898. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  899. // Establish connection.
  900. TestCompletionCallback connect_callback;
  901. int client_ret = client_socket_->Connect(connect_callback.callback());
  902. ASSERT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
  903. TestCompletionCallback handshake_callback;
  904. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  905. ASSERT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
  906. client_ret = connect_callback.GetResult(client_ret);
  907. ASSERT_THAT(client_ret, IsOk());
  908. server_ret = handshake_callback.GetResult(server_ret);
  909. ASSERT_THAT(server_ret, IsOk());
  910. scoped_refptr<StringIOBuffer> write_buf =
  911. base::MakeRefCounted<StringIOBuffer>("testing123");
  912. // The server closes the connection. The server needs to write some
  913. // data first so that the client's Read() calls from the transport
  914. // socket won't return ERR_IO_PENDING. This ensures that the client
  915. // will call Read() on the transport socket again.
  916. TestCompletionCallback write_callback;
  917. server_ret = server_socket_->Write(write_buf.get(), write_buf->size(),
  918. write_callback.callback(),
  919. TRAFFIC_ANNOTATION_FOR_TESTS);
  920. EXPECT_TRUE(server_ret > 0 || server_ret == ERR_IO_PENDING);
  921. server_ret = write_callback.GetResult(server_ret);
  922. EXPECT_GT(server_ret, 0);
  923. server_socket_->Disconnect();
  924. // The client writes some data. This should not cause an infinite loop.
  925. client_ret = client_socket_->Write(write_buf.get(), write_buf->size(),
  926. write_callback.callback(),
  927. TRAFFIC_ANNOTATION_FOR_TESTS);
  928. EXPECT_TRUE(client_ret > 0 || client_ret == ERR_IO_PENDING);
  929. client_ret = write_callback.GetResult(client_ret);
  930. EXPECT_GT(client_ret, 0);
  931. base::RunLoop run_loop;
  932. base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
  933. FROM_HERE, run_loop.QuitClosure(), base::Milliseconds(10));
  934. run_loop.Run();
  935. }
  936. // This test executes ExportKeyingMaterial() on the client and server sockets,
  937. // after connecting them, and verifies that the results match.
  938. // This test will fail if False Start is enabled (see crbug.com/90208).
  939. TEST_F(SSLServerSocketTest, ExportKeyingMaterial) {
  940. ASSERT_NO_FATAL_FAILURE(CreateContext());
  941. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  942. TestCompletionCallback connect_callback;
  943. int client_ret = client_socket_->Connect(connect_callback.callback());
  944. ASSERT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
  945. TestCompletionCallback handshake_callback;
  946. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  947. ASSERT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
  948. if (client_ret == ERR_IO_PENDING) {
  949. ASSERT_THAT(connect_callback.WaitForResult(), IsOk());
  950. }
  951. if (server_ret == ERR_IO_PENDING) {
  952. ASSERT_THAT(handshake_callback.WaitForResult(), IsOk());
  953. }
  954. const int kKeyingMaterialSize = 32;
  955. const char kKeyingLabel[] = "EXPERIMENTAL-server-socket-test";
  956. const char kKeyingContext[] = "";
  957. unsigned char server_out[kKeyingMaterialSize];
  958. int rv = server_socket_->ExportKeyingMaterial(
  959. kKeyingLabel, false, kKeyingContext, server_out, sizeof(server_out));
  960. ASSERT_THAT(rv, IsOk());
  961. unsigned char client_out[kKeyingMaterialSize];
  962. rv = client_socket_->ExportKeyingMaterial(kKeyingLabel, false, kKeyingContext,
  963. client_out, sizeof(client_out));
  964. ASSERT_THAT(rv, IsOk());
  965. EXPECT_EQ(0, memcmp(server_out, client_out, sizeof(server_out)));
  966. const char kKeyingLabelBad[] = "EXPERIMENTAL-server-socket-test-bad";
  967. unsigned char client_bad[kKeyingMaterialSize];
  968. rv = client_socket_->ExportKeyingMaterial(
  969. kKeyingLabelBad, false, kKeyingContext, client_bad, sizeof(client_bad));
  970. ASSERT_EQ(rv, OK);
  971. EXPECT_NE(0, memcmp(server_out, client_bad, sizeof(server_out)));
  972. }
  973. // Verifies that SSLConfig::require_ecdhe flags works properly.
  974. TEST_F(SSLServerSocketTest, RequireEcdheFlag) {
  975. // Disable all ECDHE suites on the client side.
  976. uint16_t kEcdheCiphers[] = {
  977. 0xc007, // ECDHE_ECDSA_WITH_RC4_128_SHA
  978. 0xc009, // ECDHE_ECDSA_WITH_AES_128_CBC_SHA
  979. 0xc00a, // ECDHE_ECDSA_WITH_AES_256_CBC_SHA
  980. 0xc011, // ECDHE_RSA_WITH_RC4_128_SHA
  981. 0xc013, // ECDHE_RSA_WITH_AES_128_CBC_SHA
  982. 0xc014, // ECDHE_RSA_WITH_AES_256_CBC_SHA
  983. 0xc02b, // ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
  984. 0xc02f, // ECDHE_RSA_WITH_AES_128_GCM_SHA256
  985. 0xcca8, // ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
  986. 0xcca9, // ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
  987. };
  988. SSLContextConfig config;
  989. config.disabled_cipher_suites.assign(
  990. kEcdheCiphers, kEcdheCiphers + std::size(kEcdheCiphers));
  991. // Legacy RSA key exchange ciphers only exist in TLS 1.2 and below.
  992. config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  993. ssl_config_service_->UpdateSSLConfigAndNotify(config);
  994. // Require ECDHE on the server.
  995. server_ssl_config_.require_ecdhe = true;
  996. ASSERT_NO_FATAL_FAILURE(CreateContext());
  997. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  998. TestCompletionCallback connect_callback;
  999. int client_ret = client_socket_->Connect(connect_callback.callback());
  1000. TestCompletionCallback handshake_callback;
  1001. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  1002. client_ret = connect_callback.GetResult(client_ret);
  1003. server_ret = handshake_callback.GetResult(server_ret);
  1004. ASSERT_THAT(client_ret, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  1005. ASSERT_THAT(server_ret, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  1006. }
  1007. // This test executes Connect() on SSLClientSocket and Handshake() on
  1008. // SSLServerSocket to make sure handshaking between the two sockets is
  1009. // completed successfully. The server key is represented by SSLPrivateKey.
  1010. TEST_F(SSLServerSocketTest, HandshakeServerSSLPrivateKey) {
  1011. ASSERT_NO_FATAL_FAILURE(CreateContextSSLPrivateKey());
  1012. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  1013. TestCompletionCallback handshake_callback;
  1014. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  1015. TestCompletionCallback connect_callback;
  1016. int client_ret = client_socket_->Connect(connect_callback.callback());
  1017. client_ret = connect_callback.GetResult(client_ret);
  1018. server_ret = handshake_callback.GetResult(server_ret);
  1019. ASSERT_THAT(client_ret, IsOk());
  1020. ASSERT_THAT(server_ret, IsOk());
  1021. // Make sure the cert status is expected.
  1022. SSLInfo ssl_info;
  1023. ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info));
  1024. EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, ssl_info.cert_status);
  1025. // The default cipher suite should be ECDHE and an AEAD.
  1026. uint16_t cipher_suite =
  1027. SSLConnectionStatusToCipherSuite(ssl_info.connection_status);
  1028. const char* key_exchange;
  1029. const char* cipher;
  1030. const char* mac;
  1031. bool is_aead;
  1032. bool is_tls13;
  1033. SSLCipherSuiteToStrings(&key_exchange, &cipher, &mac, &is_aead, &is_tls13,
  1034. cipher_suite);
  1035. EXPECT_TRUE(is_aead);
  1036. }
  1037. // Verifies that non-ECDHE ciphers are disabled when using SSLPrivateKey as the
  1038. // server key.
  1039. TEST_F(SSLServerSocketTest, HandshakeServerSSLPrivateKeyRequireEcdhe) {
  1040. // Disable all ECDHE suites on the client side.
  1041. uint16_t kEcdheCiphers[] = {
  1042. 0xc007, // ECDHE_ECDSA_WITH_RC4_128_SHA
  1043. 0xc009, // ECDHE_ECDSA_WITH_AES_128_CBC_SHA
  1044. 0xc00a, // ECDHE_ECDSA_WITH_AES_256_CBC_SHA
  1045. 0xc011, // ECDHE_RSA_WITH_RC4_128_SHA
  1046. 0xc013, // ECDHE_RSA_WITH_AES_128_CBC_SHA
  1047. 0xc014, // ECDHE_RSA_WITH_AES_256_CBC_SHA
  1048. 0xc02b, // ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
  1049. 0xc02f, // ECDHE_RSA_WITH_AES_128_GCM_SHA256
  1050. 0xcca8, // ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
  1051. 0xcca9, // ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
  1052. };
  1053. SSLContextConfig config;
  1054. config.disabled_cipher_suites.assign(
  1055. kEcdheCiphers, kEcdheCiphers + std::size(kEcdheCiphers));
  1056. // TLS 1.3 always works with SSLPrivateKey.
  1057. config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  1058. ssl_config_service_->UpdateSSLConfigAndNotify(config);
  1059. ASSERT_NO_FATAL_FAILURE(CreateContextSSLPrivateKey());
  1060. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  1061. TestCompletionCallback connect_callback;
  1062. int client_ret = client_socket_->Connect(connect_callback.callback());
  1063. TestCompletionCallback handshake_callback;
  1064. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  1065. client_ret = connect_callback.GetResult(client_ret);
  1066. server_ret = handshake_callback.GetResult(server_ret);
  1067. ASSERT_THAT(client_ret, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  1068. ASSERT_THAT(server_ret, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  1069. }
  1070. class SSLServerSocketAlpsTest
  1071. : public SSLServerSocketTest,
  1072. public ::testing::WithParamInterface<std::tuple<bool, bool>> {
  1073. public:
  1074. SSLServerSocketAlpsTest()
  1075. : client_alps_enabled_(std::get<0>(GetParam())),
  1076. server_alps_enabled_(std::get<1>(GetParam())) {}
  1077. ~SSLServerSocketAlpsTest() override = default;
  1078. const bool client_alps_enabled_;
  1079. const bool server_alps_enabled_;
  1080. };
  1081. INSTANTIATE_TEST_SUITE_P(All,
  1082. SSLServerSocketAlpsTest,
  1083. ::testing::Combine(::testing::Bool(),
  1084. ::testing::Bool()));
  1085. TEST_P(SSLServerSocketAlpsTest, Alps) {
  1086. const std::string server_data = "server sends some test data";
  1087. const std::string client_data = "client also sends some data";
  1088. server_ssl_config_.alpn_protos = {kProtoHTTP2};
  1089. if (server_alps_enabled_) {
  1090. server_ssl_config_.application_settings[kProtoHTTP2] =
  1091. std::vector<uint8_t>(server_data.begin(), server_data.end());
  1092. }
  1093. client_ssl_config_.alpn_protos = {kProtoHTTP2};
  1094. if (client_alps_enabled_) {
  1095. client_ssl_config_.application_settings[kProtoHTTP2] =
  1096. std::vector<uint8_t>(client_data.begin(), client_data.end());
  1097. }
  1098. ASSERT_NO_FATAL_FAILURE(CreateContext());
  1099. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  1100. TestCompletionCallback handshake_callback;
  1101. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  1102. TestCompletionCallback connect_callback;
  1103. int client_ret = client_socket_->Connect(connect_callback.callback());
  1104. client_ret = connect_callback.GetResult(client_ret);
  1105. server_ret = handshake_callback.GetResult(server_ret);
  1106. ASSERT_THAT(client_ret, IsOk());
  1107. ASSERT_THAT(server_ret, IsOk());
  1108. // ALPS is negotiated only if ALPS is enabled both on client and server.
  1109. const auto alps_data_received_by_client =
  1110. client_socket_->GetPeerApplicationSettings();
  1111. const auto alps_data_received_by_server =
  1112. server_socket_->GetPeerApplicationSettings();
  1113. if (client_alps_enabled_ && server_alps_enabled_) {
  1114. ASSERT_TRUE(alps_data_received_by_client.has_value());
  1115. EXPECT_EQ(server_data, alps_data_received_by_client.value());
  1116. ASSERT_TRUE(alps_data_received_by_server.has_value());
  1117. EXPECT_EQ(client_data, alps_data_received_by_server.value());
  1118. } else {
  1119. EXPECT_FALSE(alps_data_received_by_client.has_value());
  1120. EXPECT_FALSE(alps_data_received_by_server.has_value());
  1121. }
  1122. }
  1123. // Test that CancelReadIfReady works.
  1124. TEST_F(SSLServerSocketTest, CancelReadIfReady) {
  1125. ASSERT_NO_FATAL_FAILURE(CreateContext());
  1126. ASSERT_NO_FATAL_FAILURE(CreateSockets());
  1127. TestCompletionCallback connect_callback;
  1128. int client_ret = client_socket_->Connect(connect_callback.callback());
  1129. TestCompletionCallback handshake_callback;
  1130. int server_ret = server_socket_->Handshake(handshake_callback.callback());
  1131. ASSERT_THAT(connect_callback.GetResult(client_ret), IsOk());
  1132. ASSERT_THAT(handshake_callback.GetResult(server_ret), IsOk());
  1133. // Attempt to read from the server socket. There will not be anything to read.
  1134. // Cancel the read immediately afterwards.
  1135. TestCompletionCallback read_callback;
  1136. auto read_buf = base::MakeRefCounted<IOBuffer>(1);
  1137. int read_ret =
  1138. server_socket_->ReadIfReady(read_buf.get(), 1, read_callback.callback());
  1139. ASSERT_THAT(read_ret, IsError(ERR_IO_PENDING));
  1140. ASSERT_THAT(server_socket_->CancelReadIfReady(), IsOk());
  1141. // After the client writes data, the server should still not pick up a result.
  1142. auto write_buf = base::MakeRefCounted<StringIOBuffer>("a");
  1143. TestCompletionCallback write_callback;
  1144. ASSERT_EQ(write_callback.GetResult(client_socket_->Write(
  1145. write_buf.get(), write_buf->size(), write_callback.callback(),
  1146. TRAFFIC_ANNOTATION_FOR_TESTS)),
  1147. write_buf->size());
  1148. base::RunLoop().RunUntilIdle();
  1149. EXPECT_FALSE(read_callback.have_result());
  1150. // After a canceled read, future reads are still possible.
  1151. while (true) {
  1152. TestCompletionCallback read_callback2;
  1153. read_ret = server_socket_->ReadIfReady(read_buf.get(), 1,
  1154. read_callback2.callback());
  1155. if (read_ret != ERR_IO_PENDING) {
  1156. break;
  1157. }
  1158. ASSERT_THAT(read_callback2.GetResult(read_ret), IsOk());
  1159. }
  1160. ASSERT_EQ(1, read_ret);
  1161. EXPECT_EQ(read_buf->data()[0], 'a');
  1162. }
  1163. } // namespace net