2 * Copyright 2016 Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 #include <folly/io/async/test/AsyncSSLSocketTest.h>
21 #include <folly/SocketAddress.h>
22 #include <folly/io/async/AsyncSSLSocket.h>
23 #include <folly/io/async/EventBase.h>
24 #include <folly/portability/Sockets.h>
25 #include <folly/portability/Unistd.h>
27 #include <folly/io/async/test/BlockingSocket.h>
30 #include <folly/io/Cursor.h>
31 #include <gtest/gtest.h>
32 #include <openssl/bio.h>
33 #include <sys/types.h>
40 #include <gmock/gmock.h>
49 using namespace testing;
52 uint32_t TestSSLAsyncCacheServer::asyncCallbacks_ = 0;
53 uint32_t TestSSLAsyncCacheServer::asyncLookups_ = 0;
54 uint32_t TestSSLAsyncCacheServer::lookupDelay_ = 0;
56 const char* testCert = "folly/io/async/test/certs/tests-cert.pem";
57 const char* testKey = "folly/io/async/test/certs/tests-key.pem";
58 const char* testCA = "folly/io/async/test/certs/ca-cert.pem";
60 constexpr size_t SSLClient::kMaxReadBufferSz;
61 constexpr size_t SSLClient::kMaxReadsPerEvent;
63 TestSSLServer::TestSSLServer(SSLServerAcceptCallbackBase* acb, bool enableTFO)
64 : ctx_(new folly::SSLContext),
66 socket_(folly::AsyncServerSocket::newSocket(&evb_)) {
67 // Set up the SSL context
68 ctx_->loadCertificate(testCert);
69 ctx_->loadPrivateKey(testKey);
70 ctx_->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
77 LOG(INFO) << "server TFO enabled";
78 socket_->setTFOEnabled(true, 1000);
81 // set up the listening socket
83 socket_->getAddress(&address_);
85 socket_->addAcceptCallback(acb_, &evb_);
86 socket_->startAccepting();
88 int ret = pthread_create(&thread_, nullptr, Main, this);
92 std::cerr << "Accepting connections on " << address_ << std::endl;
95 void getfds(int fds[2]) {
96 if (socketpair(PF_LOCAL, SOCK_STREAM, 0, fds) != 0) {
97 FAIL() << "failed to create socketpair: " << strerror(errno);
99 for (int idx = 0; idx < 2; ++idx) {
100 int flags = fcntl(fds[idx], F_GETFL, 0);
102 FAIL() << "failed to get flags for socket " << idx << ": "
105 if (fcntl(fds[idx], F_SETFL, flags | O_NONBLOCK) != 0) {
106 FAIL() << "failed to put socket " << idx << " in non-blocking mode: "
113 std::shared_ptr<folly::SSLContext> clientCtx,
114 std::shared_ptr<folly::SSLContext> serverCtx) {
115 clientCtx->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
117 serverCtx->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
118 serverCtx->loadCertificate(
120 serverCtx->loadPrivateKey(
125 EventBase* eventBase,
126 AsyncSSLSocket::UniquePtr* clientSock,
127 AsyncSSLSocket::UniquePtr* serverSock) {
128 auto clientCtx = std::make_shared<folly::SSLContext>();
129 auto serverCtx = std::make_shared<folly::SSLContext>();
132 getctx(clientCtx, serverCtx);
133 clientSock->reset(new AsyncSSLSocket(
134 clientCtx, eventBase, fds[0], false));
135 serverSock->reset(new AsyncSSLSocket(
136 serverCtx, eventBase, fds[1], true));
138 // (*clientSock)->setSendTimeout(100);
139 // (*serverSock)->setSendTimeout(100);
142 // client protocol filters
143 bool clientProtoFilterPickPony(unsigned char** client,
144 unsigned int* client_len, const unsigned char*, unsigned int ) {
145 //the protocol string in length prefixed byte string. the
146 //length byte is not included in the length
147 static unsigned char p[7] = {6,'p','o','n','i','e','s'};
153 bool clientProtoFilterPickNone(unsigned char**, unsigned int*,
154 const unsigned char*, unsigned int) {
158 std::string getFileAsBuf(const char* fileName) {
160 folly::readFile(fileName, buffer);
164 std::string getCommonName(X509* cert) {
165 X509_NAME* subject = X509_get_subject_name(cert);
167 cn.resize(ub_common_name);
168 X509_NAME_get_text_by_NID(
169 subject, NID_commonName, const_cast<char*>(cn.data()), ub_common_name);
174 * Test connecting to, writing to, reading from, and closing the
175 * connection to the SSL server.
177 TEST(AsyncSSLSocketTest, ConnectWriteReadClose) {
178 // Start listening on a local port
179 WriteCallbackBase writeCallback;
180 ReadCallback readCallback(&writeCallback);
181 HandshakeCallback handshakeCallback(&readCallback);
182 SSLServerAcceptCallback acceptCallback(&handshakeCallback);
183 TestSSLServer server(&acceptCallback);
185 // Set up SSL context.
186 std::shared_ptr<SSLContext> sslContext(new SSLContext());
187 sslContext->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
188 //sslContext->loadTrustedCertificates("./trusted-ca-certificate.pem");
189 //sslContext->authenticate(true, false);
192 auto socket = std::make_shared<BlockingSocket>(server.getAddress(),
198 memset(buf, 'a', sizeof(buf));
199 socket->write(buf, sizeof(buf));
202 uint8_t readbuf[128];
203 uint32_t bytesRead = socket->readAll(readbuf, sizeof(readbuf));
204 EXPECT_EQ(bytesRead, 128);
205 EXPECT_EQ(memcmp(buf, readbuf, bytesRead), 0);
210 cerr << "ConnectWriteReadClose test completed" << endl;
214 * Test reading after server close.
216 TEST(AsyncSSLSocketTest, ReadAfterClose) {
217 // Start listening on a local port
218 WriteCallbackBase writeCallback;
219 ReadEOFCallback readCallback(&writeCallback);
220 HandshakeCallback handshakeCallback(&readCallback);
221 SSLServerAcceptCallback acceptCallback(&handshakeCallback);
222 auto server = folly::make_unique<TestSSLServer>(&acceptCallback);
224 // Set up SSL context.
225 auto sslContext = std::make_shared<SSLContext>();
226 sslContext->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
229 std::make_shared<BlockingSocket>(server->getAddress(), sslContext);
232 // This should trigger an EOF on the client.
233 auto evb = handshakeCallback.getSocket()->getEventBase();
234 evb->runInEventBaseThreadAndWait([&]() { handshakeCallback.closeSocket(); });
235 std::array<uint8_t, 128> readbuf;
236 auto bytesRead = socket->read(readbuf.data(), readbuf.size());
237 EXPECT_EQ(0, bytesRead);
241 * Test bad renegotiation
243 TEST(AsyncSSLSocketTest, Renegotiate) {
245 auto clientCtx = std::make_shared<SSLContext>();
246 auto dfServerCtx = std::make_shared<SSLContext>();
247 std::array<int, 2> fds;
249 getctx(clientCtx, dfServerCtx);
251 AsyncSSLSocket::UniquePtr clientSock(
252 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
253 AsyncSSLSocket::UniquePtr serverSock(
254 new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
255 SSLHandshakeClient client(std::move(clientSock), true, true);
256 RenegotiatingServer server(std::move(serverSock));
258 while (!client.handshakeSuccess_ && !client.handshakeError_) {
259 eventBase.loopOnce();
262 ASSERT_TRUE(client.handshakeSuccess_);
264 auto sslSock = std::move(client).moveSocket();
265 sslSock->detachEventBase();
266 // This is nasty, however we don't want to add support for
267 // renegotiation in AsyncSSLSocket.
268 SSL_renegotiate(const_cast<SSL*>(sslSock->getSSL()));
270 auto socket = std::make_shared<BlockingSocket>(std::move(sslSock));
272 std::thread t([&]() { eventBase.loopForever(); });
274 // Trigger the renegotiation.
275 std::array<uint8_t, 128> buf;
276 memset(buf.data(), 'a', buf.size());
278 socket->write(buf.data(), buf.size());
279 } catch (AsyncSocketException& e) {
280 LOG(INFO) << "client got error " << e.what();
282 eventBase.terminateLoopSoon();
286 ASSERT_TRUE(server.renegotiationError_);
290 * Negative test for handshakeError().
292 TEST(AsyncSSLSocketTest, HandshakeError) {
293 // Start listening on a local port
294 WriteCallbackBase writeCallback;
295 WriteErrorCallback readCallback(&writeCallback);
296 HandshakeCallback handshakeCallback(&readCallback);
297 HandshakeErrorCallback acceptCallback(&handshakeCallback);
298 TestSSLServer server(&acceptCallback);
300 // Set up SSL context.
301 std::shared_ptr<SSLContext> sslContext(new SSLContext());
302 sslContext->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
305 auto socket = std::make_shared<BlockingSocket>(server.getAddress(),
312 uint8_t readbuf[128];
313 uint32_t bytesRead = socket->readAll(readbuf, sizeof(readbuf));
314 LOG(ERROR) << "readAll returned " << bytesRead << " instead of throwing";
315 } catch (AsyncSocketException &e) {
322 cerr << "HandshakeError test completed" << endl;
326 * Negative test for readError().
328 TEST(AsyncSSLSocketTest, ReadError) {
329 // Start listening on a local port
330 WriteCallbackBase writeCallback;
331 ReadErrorCallback readCallback(&writeCallback);
332 HandshakeCallback handshakeCallback(&readCallback);
333 SSLServerAcceptCallback acceptCallback(&handshakeCallback);
334 TestSSLServer server(&acceptCallback);
336 // Set up SSL context.
337 std::shared_ptr<SSLContext> sslContext(new SSLContext());
338 sslContext->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
341 auto socket = std::make_shared<BlockingSocket>(server.getAddress(),
345 // write something to trigger ssl handshake
347 memset(buf, 'a', sizeof(buf));
348 socket->write(buf, sizeof(buf));
351 cerr << "ReadError test completed" << endl;
355 * Negative test for writeError().
357 TEST(AsyncSSLSocketTest, WriteError) {
358 // Start listening on a local port
359 WriteCallbackBase writeCallback;
360 WriteErrorCallback readCallback(&writeCallback);
361 HandshakeCallback handshakeCallback(&readCallback);
362 SSLServerAcceptCallback acceptCallback(&handshakeCallback);
363 TestSSLServer server(&acceptCallback);
365 // Set up SSL context.
366 std::shared_ptr<SSLContext> sslContext(new SSLContext());
367 sslContext->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
370 auto socket = std::make_shared<BlockingSocket>(server.getAddress(),
374 // write something to trigger ssl handshake
376 memset(buf, 'a', sizeof(buf));
377 socket->write(buf, sizeof(buf));
380 cerr << "WriteError test completed" << endl;
384 * Test a socket with TCP_NODELAY unset.
386 TEST(AsyncSSLSocketTest, SocketWithDelay) {
387 // Start listening on a local port
388 WriteCallbackBase writeCallback;
389 ReadCallback readCallback(&writeCallback);
390 HandshakeCallback handshakeCallback(&readCallback);
391 SSLServerAcceptCallbackDelay acceptCallback(&handshakeCallback);
392 TestSSLServer server(&acceptCallback);
394 // Set up SSL context.
395 std::shared_ptr<SSLContext> sslContext(new SSLContext());
396 sslContext->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
399 auto socket = std::make_shared<BlockingSocket>(server.getAddress(),
405 memset(buf, 'a', sizeof(buf));
406 socket->write(buf, sizeof(buf));
409 uint8_t readbuf[128];
410 uint32_t bytesRead = socket->readAll(readbuf, sizeof(readbuf));
411 EXPECT_EQ(bytesRead, 128);
412 EXPECT_EQ(memcmp(buf, readbuf, bytesRead), 0);
417 cerr << "SocketWithDelay test completed" << endl;
420 using NextProtocolTypePair =
421 std::pair<SSLContext::NextProtocolType, SSLContext::NextProtocolType>;
423 class NextProtocolTest : public testing::TestWithParam<NextProtocolTypePair> {
424 // For matching protos
426 void SetUp() override { getctx(clientCtx, serverCtx); }
428 void connect(bool unset = false) {
432 // unsetting NPN for any of [client, server] is enough to make NPN not
434 clientCtx->unsetNextProtocols();
437 AsyncSSLSocket::UniquePtr clientSock(
438 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
439 AsyncSSLSocket::UniquePtr serverSock(
440 new AsyncSSLSocket(serverCtx, &eventBase, fds[1], true));
441 client = folly::make_unique<NpnClient>(std::move(clientSock));
442 server = folly::make_unique<NpnServer>(std::move(serverSock));
447 void expectProtocol(const std::string& proto) {
448 EXPECT_NE(client->nextProtoLength, 0);
449 EXPECT_EQ(client->nextProtoLength, server->nextProtoLength);
451 memcmp(client->nextProto, server->nextProto, server->nextProtoLength),
453 string selected((const char*)client->nextProto, client->nextProtoLength);
454 EXPECT_EQ(proto, selected);
457 void expectNoProtocol() {
458 EXPECT_EQ(client->nextProtoLength, 0);
459 EXPECT_EQ(server->nextProtoLength, 0);
460 EXPECT_EQ(client->nextProto, nullptr);
461 EXPECT_EQ(server->nextProto, nullptr);
464 void expectProtocolType() {
465 if (GetParam().first == SSLContext::NextProtocolType::ANY &&
466 GetParam().second == SSLContext::NextProtocolType::ANY) {
467 EXPECT_EQ(client->protocolType, server->protocolType);
468 } else if (GetParam().first == SSLContext::NextProtocolType::ANY ||
469 GetParam().second == SSLContext::NextProtocolType::ANY) {
470 // Well not much we can say
472 expectProtocolType(GetParam());
476 void expectProtocolType(NextProtocolTypePair expected) {
477 EXPECT_EQ(client->protocolType, expected.first);
478 EXPECT_EQ(server->protocolType, expected.second);
482 std::shared_ptr<SSLContext> clientCtx{std::make_shared<SSLContext>()};
483 std::shared_ptr<SSLContext> serverCtx{std::make_shared<SSLContext>()};
485 std::unique_ptr<NpnClient> client;
486 std::unique_ptr<NpnServer> server;
489 class NextProtocolTLSExtTest : public NextProtocolTest {
490 // For extended TLS protos
493 class NextProtocolNPNOnlyTest : public NextProtocolTest {
494 // For mismatching protos
497 class NextProtocolMismatchTest : public NextProtocolTest {
498 // For mismatching protos
501 TEST_P(NextProtocolTest, NpnTestOverlap) {
502 clientCtx->setAdvertisedNextProtocols({"blub", "baz"}, GetParam().first);
503 serverCtx->setAdvertisedNextProtocols({"foo", "bar", "baz"},
508 expectProtocol("baz");
509 expectProtocolType();
512 TEST_P(NextProtocolTest, NpnTestUnset) {
513 // Identical to above test, except that we want unset NPN before
515 clientCtx->setAdvertisedNextProtocols({"blub", "baz"}, GetParam().first);
516 serverCtx->setAdvertisedNextProtocols({"foo", "bar", "baz"},
519 connect(true /* unset */);
521 // if alpn negotiation fails, type will appear as npn
523 EXPECT_EQ(client->protocolType, server->protocolType);
526 TEST_P(NextProtocolMismatchTest, NpnAlpnTestNoOverlap) {
527 clientCtx->setAdvertisedNextProtocols({"foo"}, GetParam().first);
528 serverCtx->setAdvertisedNextProtocols({"foo", "bar", "baz"},
535 {SSLContext::NextProtocolType::NPN, SSLContext::NextProtocolType::NPN});
538 // Note: the behavior changed in the ANY/ANY case in OpenSSL 1.0.2h, this test
539 // will fail on 1.0.2 before that.
540 TEST_P(NextProtocolTest, NpnTestNoOverlap) {
541 clientCtx->setAdvertisedNextProtocols({"blub"}, GetParam().first);
542 serverCtx->setAdvertisedNextProtocols({"foo", "bar", "baz"},
547 if (GetParam().first == SSLContext::NextProtocolType::ALPN ||
548 GetParam().second == SSLContext::NextProtocolType::ALPN) {
549 // This is arguably incorrect behavior since RFC7301 states an ALPN protocol
550 // mismatch should result in a fatal alert, but this is OpenSSL's current
551 // behavior and we want to know if it changes.
554 expectProtocol("blub");
556 {SSLContext::NextProtocolType::NPN, SSLContext::NextProtocolType::NPN});
560 TEST_P(NextProtocolNPNOnlyTest, NpnTestClientProtoFilterHit) {
561 clientCtx->setAdvertisedNextProtocols({"blub"}, GetParam().first);
562 clientCtx->setClientProtocolFilterCallback(clientProtoFilterPickPony);
563 serverCtx->setAdvertisedNextProtocols({"foo", "bar", "baz"},
568 expectProtocol("ponies");
569 expectProtocolType();
572 TEST_P(NextProtocolNPNOnlyTest, NpnTestClientProtoFilterMiss) {
573 clientCtx->setAdvertisedNextProtocols({"blub"}, GetParam().first);
574 clientCtx->setClientProtocolFilterCallback(clientProtoFilterPickNone);
575 serverCtx->setAdvertisedNextProtocols({"foo", "bar", "baz"},
580 expectProtocol("blub");
581 expectProtocolType();
584 TEST_P(NextProtocolTest, RandomizedNpnTest) {
585 // Probability that this test will fail is 2^-64, which could be considered
587 const int kTries = 64;
589 clientCtx->setAdvertisedNextProtocols({"foo", "bar", "baz"},
591 serverCtx->setRandomizedAdvertisedNextProtocols({{1, {"foo"}}, {1, {"bar"}}},
594 std::set<string> selectedProtocols;
595 for (int i = 0; i < kTries; ++i) {
598 EXPECT_NE(client->nextProtoLength, 0);
599 EXPECT_EQ(client->nextProtoLength, server->nextProtoLength);
601 memcmp(client->nextProto, server->nextProto, server->nextProtoLength),
603 string selected((const char*)client->nextProto, client->nextProtoLength);
604 selectedProtocols.insert(selected);
605 expectProtocolType();
607 EXPECT_EQ(selectedProtocols.size(), 2);
610 INSTANTIATE_TEST_CASE_P(
614 NextProtocolTypePair(
615 SSLContext::NextProtocolType::NPN,
616 SSLContext::NextProtocolType::NPN),
617 NextProtocolTypePair(
618 SSLContext::NextProtocolType::NPN,
619 SSLContext::NextProtocolType::ANY),
620 NextProtocolTypePair(
621 SSLContext::NextProtocolType::ANY,
622 SSLContext::NextProtocolType::ANY)));
624 #if OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined(OPENSSL_NO_TLSEXT)
625 INSTANTIATE_TEST_CASE_P(
627 NextProtocolTLSExtTest,
629 NextProtocolTypePair(
630 SSLContext::NextProtocolType::ALPN,
631 SSLContext::NextProtocolType::ALPN),
632 NextProtocolTypePair(
633 SSLContext::NextProtocolType::ALPN,
634 SSLContext::NextProtocolType::ANY),
635 NextProtocolTypePair(
636 SSLContext::NextProtocolType::ANY,
637 SSLContext::NextProtocolType::ALPN)));
640 INSTANTIATE_TEST_CASE_P(
642 NextProtocolNPNOnlyTest,
643 ::testing::Values(NextProtocolTypePair(SSLContext::NextProtocolType::NPN,
644 SSLContext::NextProtocolType::NPN)));
646 #if OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined(OPENSSL_NO_TLSEXT)
647 INSTANTIATE_TEST_CASE_P(
649 NextProtocolMismatchTest,
650 ::testing::Values(NextProtocolTypePair(SSLContext::NextProtocolType::NPN,
651 SSLContext::NextProtocolType::ALPN),
652 NextProtocolTypePair(SSLContext::NextProtocolType::ALPN,
653 SSLContext::NextProtocolType::NPN)));
656 #ifndef OPENSSL_NO_TLSEXT
658 * 1. Client sends TLSEXT_HOSTNAME in client hello.
659 * 2. Server found a match SSL_CTX and use this SSL_CTX to
660 * continue the SSL handshake.
661 * 3. Server sends back TLSEXT_HOSTNAME in server hello.
663 TEST(AsyncSSLSocketTest, SNITestMatch) {
665 std::shared_ptr<SSLContext> clientCtx(new SSLContext);
666 std::shared_ptr<SSLContext> dfServerCtx(new SSLContext);
667 // Use the same SSLContext to continue the handshake after
668 // tlsext_hostname match.
669 std::shared_ptr<SSLContext> hskServerCtx(dfServerCtx);
670 const std::string serverName("xyz.newdev.facebook.com");
673 getctx(clientCtx, dfServerCtx);
675 AsyncSSLSocket::UniquePtr clientSock(
676 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], serverName));
677 AsyncSSLSocket::UniquePtr serverSock(
678 new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
679 SNIClient client(std::move(clientSock));
680 SNIServer server(std::move(serverSock),
687 EXPECT_TRUE(client.serverNameMatch);
688 EXPECT_TRUE(server.serverNameMatch);
692 * 1. Client sends TLSEXT_HOSTNAME in client hello.
693 * 2. Server cannot find a matching SSL_CTX and continue to use
694 * the current SSL_CTX to do the handshake.
695 * 3. Server does not send back TLSEXT_HOSTNAME in server hello.
697 TEST(AsyncSSLSocketTest, SNITestNotMatch) {
699 std::shared_ptr<SSLContext> clientCtx(new SSLContext);
700 std::shared_ptr<SSLContext> dfServerCtx(new SSLContext);
701 // Use the same SSLContext to continue the handshake after
702 // tlsext_hostname match.
703 std::shared_ptr<SSLContext> hskServerCtx(dfServerCtx);
704 const std::string clientRequestingServerName("foo.com");
705 const std::string serverExpectedServerName("xyz.newdev.facebook.com");
709 getctx(clientCtx, dfServerCtx);
711 AsyncSSLSocket::UniquePtr clientSock(
712 new AsyncSSLSocket(clientCtx,
715 clientRequestingServerName));
716 AsyncSSLSocket::UniquePtr serverSock(
717 new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
718 SNIClient client(std::move(clientSock));
719 SNIServer server(std::move(serverSock),
722 serverExpectedServerName);
726 EXPECT_TRUE(!client.serverNameMatch);
727 EXPECT_TRUE(!server.serverNameMatch);
730 * 1. Client sends TLSEXT_HOSTNAME in client hello.
731 * 2. We then change the serverName.
732 * 3. We expect that we get 'false' as the result for serNameMatch.
735 TEST(AsyncSSLSocketTest, SNITestChangeServerName) {
737 std::shared_ptr<SSLContext> clientCtx(new SSLContext);
738 std::shared_ptr<SSLContext> dfServerCtx(new SSLContext);
739 // Use the same SSLContext to continue the handshake after
740 // tlsext_hostname match.
741 std::shared_ptr<SSLContext> hskServerCtx(dfServerCtx);
742 const std::string serverName("xyz.newdev.facebook.com");
745 getctx(clientCtx, dfServerCtx);
747 AsyncSSLSocket::UniquePtr clientSock(
748 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], serverName));
749 //Change the server name
750 std::string newName("new.com");
751 clientSock->setServerName(newName);
752 AsyncSSLSocket::UniquePtr serverSock(
753 new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
754 SNIClient client(std::move(clientSock));
755 SNIServer server(std::move(serverSock),
762 EXPECT_TRUE(!client.serverNameMatch);
766 * 1. Client does not send TLSEXT_HOSTNAME in client hello.
767 * 2. Server does not send back TLSEXT_HOSTNAME in server hello.
769 TEST(AsyncSSLSocketTest, SNITestClientHelloNoHostname) {
771 std::shared_ptr<SSLContext> clientCtx(new SSLContext);
772 std::shared_ptr<SSLContext> dfServerCtx(new SSLContext);
773 // Use the same SSLContext to continue the handshake after
774 // tlsext_hostname match.
775 std::shared_ptr<SSLContext> hskServerCtx(dfServerCtx);
776 const std::string serverExpectedServerName("xyz.newdev.facebook.com");
780 getctx(clientCtx, dfServerCtx);
782 AsyncSSLSocket::UniquePtr clientSock(
783 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
784 AsyncSSLSocket::UniquePtr serverSock(
785 new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
786 SNIClient client(std::move(clientSock));
787 SNIServer server(std::move(serverSock),
790 serverExpectedServerName);
794 EXPECT_TRUE(!client.serverNameMatch);
795 EXPECT_TRUE(!server.serverNameMatch);
800 * Test SSL client socket
802 TEST(AsyncSSLSocketTest, SSLClientTest) {
803 // Start listening on a local port
804 WriteCallbackBase writeCallback;
805 ReadCallback readCallback(&writeCallback);
806 HandshakeCallback handshakeCallback(&readCallback);
807 SSLServerAcceptCallbackDelay acceptCallback(&handshakeCallback);
808 TestSSLServer server(&acceptCallback);
812 auto client = std::make_shared<SSLClient>(&eventBase, server.getAddress(), 1);
815 EventBaseAborter eba(&eventBase, 3000);
818 EXPECT_EQ(client->getMiss(), 1);
819 EXPECT_EQ(client->getHit(), 0);
821 cerr << "SSLClientTest test completed" << endl;
826 * Test SSL client socket session re-use
828 TEST(AsyncSSLSocketTest, SSLClientTestReuse) {
829 // Start listening on a local port
830 WriteCallbackBase writeCallback;
831 ReadCallback readCallback(&writeCallback);
832 HandshakeCallback handshakeCallback(&readCallback);
833 SSLServerAcceptCallbackDelay acceptCallback(&handshakeCallback);
834 TestSSLServer server(&acceptCallback);
839 std::make_shared<SSLClient>(&eventBase, server.getAddress(), 10);
842 EventBaseAborter eba(&eventBase, 3000);
845 EXPECT_EQ(client->getMiss(), 1);
846 EXPECT_EQ(client->getHit(), 9);
848 cerr << "SSLClientTestReuse test completed" << endl;
852 * Test SSL client socket timeout
854 TEST(AsyncSSLSocketTest, SSLClientTimeoutTest) {
855 // Start listening on a local port
856 EmptyReadCallback readCallback;
857 HandshakeCallback handshakeCallback(&readCallback,
858 HandshakeCallback::EXPECT_ERROR);
859 HandshakeTimeoutCallback acceptCallback(&handshakeCallback);
860 TestSSLServer server(&acceptCallback);
865 std::make_shared<SSLClient>(&eventBase, server.getAddress(), 1, 10);
866 client->connect(true /* write before connect completes */);
867 EventBaseAborter eba(&eventBase, 3000);
871 // This is checking that the connectError callback precedes any queued
872 // writeError callbacks. This matches AsyncSocket's behavior
873 EXPECT_EQ(client->getWriteAfterConnectErrors(), 1);
874 EXPECT_EQ(client->getErrors(), 1);
875 EXPECT_EQ(client->getMiss(), 0);
876 EXPECT_EQ(client->getHit(), 0);
878 cerr << "SSLClientTimeoutTest test completed" << endl;
883 * Test SSL server async cache
885 TEST(AsyncSSLSocketTest, SSLServerAsyncCacheTest) {
886 // Start listening on a local port
887 WriteCallbackBase writeCallback;
888 ReadCallback readCallback(&writeCallback);
889 HandshakeCallback handshakeCallback(&readCallback);
890 SSLServerAsyncCacheAcceptCallback acceptCallback(&handshakeCallback);
891 TestSSLAsyncCacheServer server(&acceptCallback);
896 std::make_shared<SSLClient>(&eventBase, server.getAddress(), 10, 500);
899 EventBaseAborter eba(&eventBase, 3000);
902 EXPECT_EQ(server.getAsyncCallbacks(), 18);
903 EXPECT_EQ(server.getAsyncLookups(), 9);
904 EXPECT_EQ(client->getMiss(), 10);
905 EXPECT_EQ(client->getHit(), 0);
907 cerr << "SSLServerAsyncCacheTest test completed" << endl;
912 * Test SSL server accept timeout with cache path
914 TEST(AsyncSSLSocketTest, SSLServerTimeoutTest) {
915 // Start listening on a local port
916 WriteCallbackBase writeCallback;
917 ReadCallback readCallback(&writeCallback);
918 EmptyReadCallback clientReadCallback;
919 HandshakeCallback handshakeCallback(&readCallback);
920 SSLServerAcceptCallback acceptCallback(&handshakeCallback, 50);
921 TestSSLAsyncCacheServer server(&acceptCallback);
925 // only do a TCP connect
926 std::shared_ptr<AsyncSocket> sock = AsyncSocket::newSocket(&eventBase);
927 sock->connect(nullptr, server.getAddress());
928 clientReadCallback.tcpSocket_ = sock;
929 sock->setReadCB(&clientReadCallback);
931 EventBaseAborter eba(&eventBase, 3000);
934 EXPECT_EQ(readCallback.state, STATE_WAITING);
936 cerr << "SSLServerTimeoutTest test completed" << endl;
940 * Test SSL server accept timeout with cache path
942 TEST(AsyncSSLSocketTest, SSLServerAsyncCacheTimeoutTest) {
943 // Start listening on a local port
944 WriteCallbackBase writeCallback;
945 ReadCallback readCallback(&writeCallback);
946 HandshakeCallback handshakeCallback(&readCallback);
947 SSLServerAsyncCacheAcceptCallback acceptCallback(&handshakeCallback, 50);
948 TestSSLAsyncCacheServer server(&acceptCallback);
952 auto client = std::make_shared<SSLClient>(&eventBase, server.getAddress(), 2);
955 EventBaseAborter eba(&eventBase, 3000);
958 EXPECT_EQ(server.getAsyncCallbacks(), 1);
959 EXPECT_EQ(server.getAsyncLookups(), 1);
960 EXPECT_EQ(client->getErrors(), 1);
961 EXPECT_EQ(client->getMiss(), 1);
962 EXPECT_EQ(client->getHit(), 0);
964 cerr << "SSLServerAsyncCacheTimeoutTest test completed" << endl;
968 * Test SSL server accept timeout with cache path
970 TEST(AsyncSSLSocketTest, SSLServerCacheCloseTest) {
971 // Start listening on a local port
972 WriteCallbackBase writeCallback;
973 ReadCallback readCallback(&writeCallback);
974 HandshakeCallback handshakeCallback(&readCallback,
975 HandshakeCallback::EXPECT_ERROR);
976 SSLServerAsyncCacheAcceptCallback acceptCallback(&handshakeCallback);
977 TestSSLAsyncCacheServer server(&acceptCallback, 500);
982 std::make_shared<SSLClient>(&eventBase, server.getAddress(), 2, 100);
985 EventBaseAborter eba(&eventBase, 3000);
988 server.getEventBase().runInEventBaseThread([&handshakeCallback]{
989 handshakeCallback.closeSocket();});
990 // give time for the cache lookup to come back and find it closed
991 handshakeCallback.waitForHandshake();
993 EXPECT_EQ(server.getAsyncCallbacks(), 1);
994 EXPECT_EQ(server.getAsyncLookups(), 1);
995 EXPECT_EQ(client->getErrors(), 1);
996 EXPECT_EQ(client->getMiss(), 1);
997 EXPECT_EQ(client->getHit(), 0);
999 cerr << "SSLServerCacheCloseTest test completed" << endl;
1003 * Verify Client Ciphers obtained using SSL MSG Callback.
1005 TEST(AsyncSSLSocketTest, SSLParseClientHelloSuccess) {
1006 EventBase eventBase;
1007 auto clientCtx = std::make_shared<SSLContext>();
1008 auto serverCtx = std::make_shared<SSLContext>();
1009 serverCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1010 serverCtx->ciphers("RSA:!SHA:!NULL:!SHA256@STRENGTH");
1011 serverCtx->loadPrivateKey(testKey);
1012 serverCtx->loadCertificate(testCert);
1013 serverCtx->loadTrustedCertificates(testCA);
1014 serverCtx->loadClientCAList(testCA);
1016 clientCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1017 clientCtx->ciphers("RC4-SHA:AES128-SHA:AES256-SHA:RC4-MD5");
1018 clientCtx->loadPrivateKey(testKey);
1019 clientCtx->loadCertificate(testCert);
1020 clientCtx->loadTrustedCertificates(testCA);
1025 AsyncSSLSocket::UniquePtr clientSock(
1026 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
1027 AsyncSSLSocket::UniquePtr serverSock(
1028 new AsyncSSLSocket(serverCtx, &eventBase, fds[1], true));
1030 SSLHandshakeClient client(std::move(clientSock), true, true);
1031 SSLHandshakeServerParseClientHello server(std::move(serverSock), true, true);
1035 EXPECT_EQ(server.clientCiphers_,
1036 "RC4-SHA:AES128-SHA:AES256-SHA:RC4-MD5:00ff");
1037 EXPECT_TRUE(client.handshakeVerify_);
1038 EXPECT_TRUE(client.handshakeSuccess_);
1039 EXPECT_TRUE(!client.handshakeError_);
1040 EXPECT_TRUE(server.handshakeVerify_);
1041 EXPECT_TRUE(server.handshakeSuccess_);
1042 EXPECT_TRUE(!server.handshakeError_);
1045 TEST(AsyncSSLSocketTest, SSLParseClientHelloOnePacket) {
1046 EventBase eventBase;
1047 auto ctx = std::make_shared<SSLContext>();
1053 uint8_t majorVersion = 18;
1054 uint8_t minorVersion = 25;
1056 // Create callback buf
1057 auto buf = IOBuf::create(bufLen);
1058 buf->append(bufLen);
1059 folly::io::RWPrivateCursor cursor(buf.get());
1060 cursor.write<uint8_t>(SSL3_MT_CLIENT_HELLO);
1061 cursor.write<uint16_t>(0);
1062 cursor.write<uint8_t>(38);
1063 cursor.write<uint8_t>(majorVersion);
1064 cursor.write<uint8_t>(minorVersion);
1066 cursor.write<uint32_t>(0);
1068 SSL* ssl = ctx->createSSL();
1069 SCOPE_EXIT { SSL_free(ssl); };
1070 AsyncSSLSocket::UniquePtr sock(
1071 new AsyncSSLSocket(ctx, &eventBase, fds[0], true));
1072 sock->enableClientHelloParsing();
1074 // Test client hello parsing in one packet
1075 AsyncSSLSocket::clientHelloParsingCallback(
1076 0, 0, SSL3_RT_HANDSHAKE, buf->data(), buf->length(), ssl, sock.get());
1079 auto parsedClientHello = sock->getClientHelloInfo();
1080 EXPECT_TRUE(parsedClientHello != nullptr);
1081 EXPECT_EQ(parsedClientHello->clientHelloMajorVersion_, majorVersion);
1082 EXPECT_EQ(parsedClientHello->clientHelloMinorVersion_, minorVersion);
1085 TEST(AsyncSSLSocketTest, SSLParseClientHelloTwoPackets) {
1086 EventBase eventBase;
1087 auto ctx = std::make_shared<SSLContext>();
1093 uint8_t majorVersion = 18;
1094 uint8_t minorVersion = 25;
1096 // Create callback buf
1097 auto buf = IOBuf::create(bufLen);
1098 buf->append(bufLen);
1099 folly::io::RWPrivateCursor cursor(buf.get());
1100 cursor.write<uint8_t>(SSL3_MT_CLIENT_HELLO);
1101 cursor.write<uint16_t>(0);
1102 cursor.write<uint8_t>(38);
1103 cursor.write<uint8_t>(majorVersion);
1104 cursor.write<uint8_t>(minorVersion);
1106 cursor.write<uint32_t>(0);
1108 SSL* ssl = ctx->createSSL();
1109 SCOPE_EXIT { SSL_free(ssl); };
1110 AsyncSSLSocket::UniquePtr sock(
1111 new AsyncSSLSocket(ctx, &eventBase, fds[0], true));
1112 sock->enableClientHelloParsing();
1114 // Test parsing with two packets with first packet size < 3
1115 auto bufCopy = folly::IOBuf::copyBuffer(buf->data(), 2);
1116 AsyncSSLSocket::clientHelloParsingCallback(
1117 0, 0, SSL3_RT_HANDSHAKE, bufCopy->data(), bufCopy->length(),
1120 bufCopy = folly::IOBuf::copyBuffer(buf->data() + 2, buf->length() - 2);
1121 AsyncSSLSocket::clientHelloParsingCallback(
1122 0, 0, SSL3_RT_HANDSHAKE, bufCopy->data(), bufCopy->length(),
1126 auto parsedClientHello = sock->getClientHelloInfo();
1127 EXPECT_TRUE(parsedClientHello != nullptr);
1128 EXPECT_EQ(parsedClientHello->clientHelloMajorVersion_, majorVersion);
1129 EXPECT_EQ(parsedClientHello->clientHelloMinorVersion_, minorVersion);
1132 TEST(AsyncSSLSocketTest, SSLParseClientHelloMultiplePackets) {
1133 EventBase eventBase;
1134 auto ctx = std::make_shared<SSLContext>();
1140 uint8_t majorVersion = 18;
1141 uint8_t minorVersion = 25;
1143 // Create callback buf
1144 auto buf = IOBuf::create(bufLen);
1145 buf->append(bufLen);
1146 folly::io::RWPrivateCursor cursor(buf.get());
1147 cursor.write<uint8_t>(SSL3_MT_CLIENT_HELLO);
1148 cursor.write<uint16_t>(0);
1149 cursor.write<uint8_t>(38);
1150 cursor.write<uint8_t>(majorVersion);
1151 cursor.write<uint8_t>(minorVersion);
1153 cursor.write<uint32_t>(0);
1155 SSL* ssl = ctx->createSSL();
1156 SCOPE_EXIT { SSL_free(ssl); };
1157 AsyncSSLSocket::UniquePtr sock(
1158 new AsyncSSLSocket(ctx, &eventBase, fds[0], true));
1159 sock->enableClientHelloParsing();
1161 // Test parsing with multiple small packets
1162 for (uint64_t i = 0; i < buf->length(); i += 3) {
1163 auto bufCopy = folly::IOBuf::copyBuffer(
1164 buf->data() + i, std::min((uint64_t)3, buf->length() - i));
1165 AsyncSSLSocket::clientHelloParsingCallback(
1166 0, 0, SSL3_RT_HANDSHAKE, bufCopy->data(), bufCopy->length(),
1171 auto parsedClientHello = sock->getClientHelloInfo();
1172 EXPECT_TRUE(parsedClientHello != nullptr);
1173 EXPECT_EQ(parsedClientHello->clientHelloMajorVersion_, majorVersion);
1174 EXPECT_EQ(parsedClientHello->clientHelloMinorVersion_, minorVersion);
1178 * Verify sucessful behavior of SSL certificate validation.
1180 TEST(AsyncSSLSocketTest, SSLHandshakeValidationSuccess) {
1181 EventBase eventBase;
1182 auto clientCtx = std::make_shared<SSLContext>();
1183 auto dfServerCtx = std::make_shared<SSLContext>();
1187 getctx(clientCtx, dfServerCtx);
1189 clientCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1190 dfServerCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1192 AsyncSSLSocket::UniquePtr clientSock(
1193 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
1194 AsyncSSLSocket::UniquePtr serverSock(
1195 new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
1197 SSLHandshakeClient client(std::move(clientSock), true, true);
1198 clientCtx->loadTrustedCertificates(testCA);
1200 SSLHandshakeServer server(std::move(serverSock), true, true);
1204 EXPECT_TRUE(client.handshakeVerify_);
1205 EXPECT_TRUE(client.handshakeSuccess_);
1206 EXPECT_TRUE(!client.handshakeError_);
1207 EXPECT_LE(0, client.handshakeTime.count());
1208 EXPECT_TRUE(!server.handshakeVerify_);
1209 EXPECT_TRUE(server.handshakeSuccess_);
1210 EXPECT_TRUE(!server.handshakeError_);
1211 EXPECT_LE(0, server.handshakeTime.count());
1215 * Verify that the client's verification callback is able to fail SSL
1216 * connection establishment.
1218 TEST(AsyncSSLSocketTest, SSLHandshakeValidationFailure) {
1219 EventBase eventBase;
1220 auto clientCtx = std::make_shared<SSLContext>();
1221 auto dfServerCtx = std::make_shared<SSLContext>();
1225 getctx(clientCtx, dfServerCtx);
1227 clientCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1228 dfServerCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1230 AsyncSSLSocket::UniquePtr clientSock(
1231 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
1232 AsyncSSLSocket::UniquePtr serverSock(
1233 new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
1235 SSLHandshakeClient client(std::move(clientSock), true, false);
1236 clientCtx->loadTrustedCertificates(testCA);
1238 SSLHandshakeServer server(std::move(serverSock), true, true);
1242 EXPECT_TRUE(client.handshakeVerify_);
1243 EXPECT_TRUE(!client.handshakeSuccess_);
1244 EXPECT_TRUE(client.handshakeError_);
1245 EXPECT_LE(0, client.handshakeTime.count());
1246 EXPECT_TRUE(!server.handshakeVerify_);
1247 EXPECT_TRUE(!server.handshakeSuccess_);
1248 EXPECT_TRUE(server.handshakeError_);
1249 EXPECT_LE(0, server.handshakeTime.count());
1253 * Verify that the options in SSLContext can be overridden in
1254 * sslConnect/Accept.i.e specifying that no validation should be performed
1255 * allows an otherwise-invalid certificate to be accepted and doesn't fire
1256 * the validation callback.
1258 TEST(AsyncSSLSocketTest, OverrideSSLCtxDisableVerify) {
1259 EventBase eventBase;
1260 auto clientCtx = std::make_shared<SSLContext>();
1261 auto dfServerCtx = std::make_shared<SSLContext>();
1265 getctx(clientCtx, dfServerCtx);
1267 clientCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1268 dfServerCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1270 AsyncSSLSocket::UniquePtr clientSock(
1271 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
1272 AsyncSSLSocket::UniquePtr serverSock(
1273 new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
1275 SSLHandshakeClientNoVerify client(std::move(clientSock), false, false);
1276 clientCtx->loadTrustedCertificates(testCA);
1278 SSLHandshakeServerNoVerify server(std::move(serverSock), false, false);
1282 EXPECT_TRUE(!client.handshakeVerify_);
1283 EXPECT_TRUE(client.handshakeSuccess_);
1284 EXPECT_TRUE(!client.handshakeError_);
1285 EXPECT_LE(0, client.handshakeTime.count());
1286 EXPECT_TRUE(!server.handshakeVerify_);
1287 EXPECT_TRUE(server.handshakeSuccess_);
1288 EXPECT_TRUE(!server.handshakeError_);
1289 EXPECT_LE(0, server.handshakeTime.count());
1293 * Verify that the options in SSLContext can be overridden in
1294 * sslConnect/Accept. Enable verification even if context says otherwise.
1295 * Test requireClientCert with client cert
1297 TEST(AsyncSSLSocketTest, OverrideSSLCtxEnableVerify) {
1298 EventBase eventBase;
1299 auto clientCtx = std::make_shared<SSLContext>();
1300 auto serverCtx = std::make_shared<SSLContext>();
1301 serverCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1302 serverCtx->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1303 serverCtx->loadPrivateKey(testKey);
1304 serverCtx->loadCertificate(testCert);
1305 serverCtx->loadTrustedCertificates(testCA);
1306 serverCtx->loadClientCAList(testCA);
1308 clientCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1309 clientCtx->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1310 clientCtx->loadPrivateKey(testKey);
1311 clientCtx->loadCertificate(testCert);
1312 clientCtx->loadTrustedCertificates(testCA);
1317 AsyncSSLSocket::UniquePtr clientSock(
1318 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
1319 AsyncSSLSocket::UniquePtr serverSock(
1320 new AsyncSSLSocket(serverCtx, &eventBase, fds[1], true));
1322 SSLHandshakeClientDoVerify client(std::move(clientSock), true, true);
1323 SSLHandshakeServerDoVerify server(std::move(serverSock), true, true);
1327 EXPECT_TRUE(client.handshakeVerify_);
1328 EXPECT_TRUE(client.handshakeSuccess_);
1329 EXPECT_FALSE(client.handshakeError_);
1330 EXPECT_LE(0, client.handshakeTime.count());
1331 EXPECT_TRUE(server.handshakeVerify_);
1332 EXPECT_TRUE(server.handshakeSuccess_);
1333 EXPECT_FALSE(server.handshakeError_);
1334 EXPECT_LE(0, server.handshakeTime.count());
1338 * Verify that the client's verification callback is able to override
1339 * the preverification failure and allow a successful connection.
1341 TEST(AsyncSSLSocketTest, SSLHandshakeValidationOverride) {
1342 EventBase eventBase;
1343 auto clientCtx = std::make_shared<SSLContext>();
1344 auto dfServerCtx = std::make_shared<SSLContext>();
1348 getctx(clientCtx, dfServerCtx);
1350 clientCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1351 dfServerCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1353 AsyncSSLSocket::UniquePtr clientSock(
1354 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
1355 AsyncSSLSocket::UniquePtr serverSock(
1356 new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
1358 SSLHandshakeClient client(std::move(clientSock), false, true);
1359 SSLHandshakeServer server(std::move(serverSock), true, true);
1363 EXPECT_TRUE(client.handshakeVerify_);
1364 EXPECT_TRUE(client.handshakeSuccess_);
1365 EXPECT_TRUE(!client.handshakeError_);
1366 EXPECT_LE(0, client.handshakeTime.count());
1367 EXPECT_TRUE(!server.handshakeVerify_);
1368 EXPECT_TRUE(server.handshakeSuccess_);
1369 EXPECT_TRUE(!server.handshakeError_);
1370 EXPECT_LE(0, server.handshakeTime.count());
1374 * Verify that specifying that no validation should be performed allows an
1375 * otherwise-invalid certificate to be accepted and doesn't fire the validation
1378 TEST(AsyncSSLSocketTest, SSLHandshakeValidationSkip) {
1379 EventBase eventBase;
1380 auto clientCtx = std::make_shared<SSLContext>();
1381 auto dfServerCtx = std::make_shared<SSLContext>();
1385 getctx(clientCtx, dfServerCtx);
1387 clientCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1388 dfServerCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1390 AsyncSSLSocket::UniquePtr clientSock(
1391 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
1392 AsyncSSLSocket::UniquePtr serverSock(
1393 new AsyncSSLSocket(dfServerCtx, &eventBase, fds[1], true));
1395 SSLHandshakeClient client(std::move(clientSock), false, false);
1396 SSLHandshakeServer server(std::move(serverSock), false, false);
1400 EXPECT_TRUE(!client.handshakeVerify_);
1401 EXPECT_TRUE(client.handshakeSuccess_);
1402 EXPECT_TRUE(!client.handshakeError_);
1403 EXPECT_LE(0, client.handshakeTime.count());
1404 EXPECT_TRUE(!server.handshakeVerify_);
1405 EXPECT_TRUE(server.handshakeSuccess_);
1406 EXPECT_TRUE(!server.handshakeError_);
1407 EXPECT_LE(0, server.handshakeTime.count());
1411 * Test requireClientCert with client cert
1413 TEST(AsyncSSLSocketTest, ClientCertHandshakeSuccess) {
1414 EventBase eventBase;
1415 auto clientCtx = std::make_shared<SSLContext>();
1416 auto serverCtx = std::make_shared<SSLContext>();
1417 serverCtx->setVerificationOption(
1418 SSLContext::SSLVerifyPeerEnum::VERIFY_REQ_CLIENT_CERT);
1419 serverCtx->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1420 serverCtx->loadPrivateKey(testKey);
1421 serverCtx->loadCertificate(testCert);
1422 serverCtx->loadTrustedCertificates(testCA);
1423 serverCtx->loadClientCAList(testCA);
1425 clientCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::VERIFY);
1426 clientCtx->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1427 clientCtx->loadPrivateKey(testKey);
1428 clientCtx->loadCertificate(testCert);
1429 clientCtx->loadTrustedCertificates(testCA);
1434 AsyncSSLSocket::UniquePtr clientSock(
1435 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
1436 AsyncSSLSocket::UniquePtr serverSock(
1437 new AsyncSSLSocket(serverCtx, &eventBase, fds[1], true));
1439 SSLHandshakeClient client(std::move(clientSock), true, true);
1440 SSLHandshakeServer server(std::move(serverSock), true, true);
1444 EXPECT_TRUE(client.handshakeVerify_);
1445 EXPECT_TRUE(client.handshakeSuccess_);
1446 EXPECT_FALSE(client.handshakeError_);
1447 EXPECT_LE(0, client.handshakeTime.count());
1448 EXPECT_TRUE(server.handshakeVerify_);
1449 EXPECT_TRUE(server.handshakeSuccess_);
1450 EXPECT_FALSE(server.handshakeError_);
1451 EXPECT_LE(0, server.handshakeTime.count());
1456 * Test requireClientCert with no client cert
1458 TEST(AsyncSSLSocketTest, NoClientCertHandshakeError) {
1459 EventBase eventBase;
1460 auto clientCtx = std::make_shared<SSLContext>();
1461 auto serverCtx = std::make_shared<SSLContext>();
1462 serverCtx->setVerificationOption(
1463 SSLContext::SSLVerifyPeerEnum::VERIFY_REQ_CLIENT_CERT);
1464 serverCtx->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1465 serverCtx->loadPrivateKey(testKey);
1466 serverCtx->loadCertificate(testCert);
1467 serverCtx->loadTrustedCertificates(testCA);
1468 serverCtx->loadClientCAList(testCA);
1469 clientCtx->setVerificationOption(SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1470 clientCtx->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1475 AsyncSSLSocket::UniquePtr clientSock(
1476 new AsyncSSLSocket(clientCtx, &eventBase, fds[0], false));
1477 AsyncSSLSocket::UniquePtr serverSock(
1478 new AsyncSSLSocket(serverCtx, &eventBase, fds[1], true));
1480 SSLHandshakeClient client(std::move(clientSock), false, false);
1481 SSLHandshakeServer server(std::move(serverSock), false, false);
1485 EXPECT_FALSE(server.handshakeVerify_);
1486 EXPECT_FALSE(server.handshakeSuccess_);
1487 EXPECT_TRUE(server.handshakeError_);
1488 EXPECT_LE(0, client.handshakeTime.count());
1489 EXPECT_LE(0, server.handshakeTime.count());
1492 TEST(AsyncSSLSocketTest, LoadCertFromMemory) {
1493 auto cert = getFileAsBuf(testCert);
1494 auto key = getFileAsBuf(testKey);
1496 ssl::BioUniquePtr certBio(BIO_new(BIO_s_mem()));
1497 BIO_write(certBio.get(), cert.data(), cert.size());
1498 ssl::BioUniquePtr keyBio(BIO_new(BIO_s_mem()));
1499 BIO_write(keyBio.get(), key.data(), key.size());
1501 // Create SSL structs from buffers to get properties
1502 ssl::X509UniquePtr certStruct(
1503 PEM_read_bio_X509(certBio.get(), nullptr, nullptr, nullptr));
1504 ssl::EvpPkeyUniquePtr keyStruct(
1505 PEM_read_bio_PrivateKey(keyBio.get(), nullptr, nullptr, nullptr));
1509 auto origCommonName = getCommonName(certStruct.get());
1510 auto origKeySize = EVP_PKEY_bits(keyStruct.get());
1511 certStruct = nullptr;
1512 keyStruct = nullptr;
1514 auto ctx = std::make_shared<SSLContext>();
1515 ctx->loadPrivateKeyFromBufferPEM(key);
1516 ctx->loadCertificateFromBufferPEM(cert);
1517 ctx->loadTrustedCertificates(testCA);
1519 ssl::SSLUniquePtr ssl(ctx->createSSL());
1521 auto newCert = SSL_get_certificate(ssl.get());
1522 auto newKey = SSL_get_privatekey(ssl.get());
1524 // Get properties from SSL struct
1525 auto newCommonName = getCommonName(newCert);
1526 auto newKeySize = EVP_PKEY_bits(newKey);
1528 // Check that the key and cert have the expected properties
1529 EXPECT_EQ(origCommonName, newCommonName);
1530 EXPECT_EQ(origKeySize, newKeySize);
1533 TEST(AsyncSSLSocketTest, MinWriteSizeTest) {
1536 // Set up SSL context.
1537 auto sslContext = std::make_shared<SSLContext>();
1538 sslContext->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1540 // create SSL socket
1541 AsyncSSLSocket::UniquePtr socket(new AsyncSSLSocket(sslContext, &eb));
1543 EXPECT_EQ(1500, socket->getMinWriteSize());
1545 socket->setMinWriteSize(0);
1546 EXPECT_EQ(0, socket->getMinWriteSize());
1547 socket->setMinWriteSize(50000);
1548 EXPECT_EQ(50000, socket->getMinWriteSize());
1551 class ReadCallbackTerminator : public ReadCallback {
1553 ReadCallbackTerminator(EventBase* base, WriteCallbackBase *wcb)
1557 // Do not write data back, terminate the loop.
1558 void readDataAvailable(size_t len) noexcept override {
1559 std::cerr << "readDataAvailable, len " << len << std::endl;
1561 currentBuffer.length = len;
1563 buffers.push_back(currentBuffer);
1564 currentBuffer.reset();
1565 state = STATE_SUCCEEDED;
1567 socket_->setReadCB(nullptr);
1568 base_->terminateLoopSoon();
1576 * Test a full unencrypted codepath
1578 TEST(AsyncSSLSocketTest, UnencryptedTest) {
1581 auto clientCtx = std::make_shared<folly::SSLContext>();
1582 auto serverCtx = std::make_shared<folly::SSLContext>();
1585 getctx(clientCtx, serverCtx);
1586 auto client = AsyncSSLSocket::newSocket(
1587 clientCtx, &base, fds[0], false, true);
1588 auto server = AsyncSSLSocket::newSocket(
1589 serverCtx, &base, fds[1], true, true);
1591 ReadCallbackTerminator readCallback(&base, nullptr);
1592 server->setReadCB(&readCallback);
1593 readCallback.setSocket(server);
1596 memset(buf, 'a', sizeof(buf));
1597 client->write(nullptr, buf, sizeof(buf));
1599 // Check that bytes are unencrypted
1601 EXPECT_EQ(1, recv(fds[1], &c, 1, MSG_PEEK));
1604 EventBaseAborter eba(&base, 3000);
1607 EXPECT_EQ(1, readCallback.buffers.size());
1608 EXPECT_EQ(AsyncSSLSocket::STATE_UNENCRYPTED, client->getSSLState());
1610 server->setReadCB(&readCallback);
1613 server->sslAccept(nullptr);
1614 client->sslConn(nullptr);
1616 // Do NOT wait for handshake, writing should be queued and happen after
1618 client->write(nullptr, buf, sizeof(buf));
1620 // Check that bytes are *not* unencrypted
1622 EXPECT_EQ(1, recv(fds[1], &c2, 1, MSG_PEEK));
1628 EXPECT_EQ(2, readCallback.buffers.size());
1629 EXPECT_EQ(AsyncSSLSocket::STATE_ESTABLISHED, client->getSSLState());
1632 TEST(AsyncSSLSocketTest, ConnResetErrorString) {
1633 // Start listening on a local port
1634 WriteCallbackBase writeCallback;
1635 WriteErrorCallback readCallback(&writeCallback);
1636 HandshakeCallback handshakeCallback(&readCallback,
1637 HandshakeCallback::EXPECT_ERROR);
1638 SSLServerAcceptCallback acceptCallback(&handshakeCallback);
1639 TestSSLServer server(&acceptCallback);
1641 auto socket = std::make_shared<BlockingSocket>(server.getAddress(), nullptr);
1643 uint8_t buf[3] = {0x16, 0x03, 0x01};
1644 socket->write(buf, sizeof(buf));
1645 socket->closeWithReset();
1647 handshakeCallback.waitForHandshake();
1649 handshakeCallback.errorString_.find("Network error"), std::string::npos);
1650 EXPECT_NE(handshakeCallback.errorString_.find("104"), std::string::npos);
1653 TEST(AsyncSSLSocketTest, ConnEOFErrorString) {
1654 // Start listening on a local port
1655 WriteCallbackBase writeCallback;
1656 WriteErrorCallback readCallback(&writeCallback);
1657 HandshakeCallback handshakeCallback(&readCallback,
1658 HandshakeCallback::EXPECT_ERROR);
1659 SSLServerAcceptCallback acceptCallback(&handshakeCallback);
1660 TestSSLServer server(&acceptCallback);
1662 auto socket = std::make_shared<BlockingSocket>(server.getAddress(), nullptr);
1664 uint8_t buf[3] = {0x16, 0x03, 0x01};
1665 socket->write(buf, sizeof(buf));
1668 handshakeCallback.waitForHandshake();
1670 handshakeCallback.errorString_.find("Connection EOF"), std::string::npos);
1671 EXPECT_NE(handshakeCallback.errorString_.find("EOF"), std::string::npos);
1674 TEST(AsyncSSLSocketTest, ConnOpenSSLErrorString) {
1675 // Start listening on a local port
1676 WriteCallbackBase writeCallback;
1677 WriteErrorCallback readCallback(&writeCallback);
1678 HandshakeCallback handshakeCallback(&readCallback,
1679 HandshakeCallback::EXPECT_ERROR);
1680 SSLServerAcceptCallback acceptCallback(&handshakeCallback);
1681 TestSSLServer server(&acceptCallback);
1683 auto socket = std::make_shared<BlockingSocket>(server.getAddress(), nullptr);
1685 uint8_t buf[256] = {0x16, 0x03};
1686 memset(buf + 2, 'a', sizeof(buf) - 2);
1687 socket->write(buf, sizeof(buf));
1690 handshakeCallback.waitForHandshake();
1691 EXPECT_NE(handshakeCallback.errorString_.find("SSL routines"),
1693 EXPECT_NE(handshakeCallback.errorString_.find("unknown protocol"),
1699 class MockAsyncTFOSSLSocket : public AsyncSSLSocket {
1701 using UniquePtr = std::unique_ptr<MockAsyncTFOSSLSocket, Destructor>;
1703 explicit MockAsyncTFOSSLSocket(
1704 std::shared_ptr<folly::SSLContext> sslCtx,
1706 : AsyncSocket(evb), AsyncSSLSocket(sslCtx, evb) {}
1708 MOCK_METHOD3(tfoSendMsg, ssize_t(int fd, struct msghdr* msg, int msg_flags));
1712 * Test connecting to, writing to, reading from, and closing the
1713 * connection to the SSL server with TFO.
1715 TEST(AsyncSSLSocketTest, ConnectWriteReadCloseTFO) {
1716 // Start listening on a local port
1717 WriteCallbackBase writeCallback;
1718 ReadCallback readCallback(&writeCallback);
1719 HandshakeCallback handshakeCallback(&readCallback);
1720 SSLServerAcceptCallback acceptCallback(&handshakeCallback);
1721 TestSSLServer server(&acceptCallback, true);
1723 // Set up SSL context.
1724 auto sslContext = std::make_shared<SSLContext>();
1728 std::make_shared<BlockingSocket>(server.getAddress(), sslContext);
1729 socket->enableTFO();
1733 std::array<uint8_t, 128> buf;
1734 memset(buf.data(), 'a', buf.size());
1735 socket->write(buf.data(), buf.size());
1738 std::array<uint8_t, 128> readbuf;
1739 uint32_t bytesRead = socket->readAll(readbuf.data(), readbuf.size());
1740 EXPECT_EQ(bytesRead, 128);
1741 EXPECT_EQ(memcmp(buf.data(), readbuf.data(), bytesRead), 0);
1748 * Test connecting to, writing to, reading from, and closing the
1749 * connection to the SSL server with TFO.
1751 TEST(AsyncSSLSocketTest, ConnectWriteReadCloseTFOWithTFOServerDisabled) {
1752 // Start listening on a local port
1753 WriteCallbackBase writeCallback;
1754 ReadCallback readCallback(&writeCallback);
1755 HandshakeCallback handshakeCallback(&readCallback);
1756 SSLServerAcceptCallback acceptCallback(&handshakeCallback);
1757 TestSSLServer server(&acceptCallback, false);
1759 // Set up SSL context.
1760 auto sslContext = std::make_shared<SSLContext>();
1764 std::make_shared<BlockingSocket>(server.getAddress(), sslContext);
1765 socket->enableTFO();
1769 std::array<uint8_t, 128> buf;
1770 memset(buf.data(), 'a', buf.size());
1771 socket->write(buf.data(), buf.size());
1774 std::array<uint8_t, 128> readbuf;
1775 uint32_t bytesRead = socket->readAll(readbuf.data(), readbuf.size());
1776 EXPECT_EQ(bytesRead, 128);
1777 EXPECT_EQ(memcmp(buf.data(), readbuf.data(), bytesRead), 0);
1783 class ConnCallback : public AsyncSocket::ConnectCallback {
1785 virtual void connectSuccess() noexcept override {
1786 state = State::SUCCESS;
1789 virtual void connectErr(const AsyncSocketException&) noexcept override {
1790 state = State::ERROR;
1793 enum class State { WAITING, SUCCESS, ERROR };
1795 State state{State::WAITING};
1798 template <class Cardinality>
1799 MockAsyncTFOSSLSocket::UniquePtr setupSocketWithFallback(
1801 const SocketAddress& address,
1802 Cardinality cardinality) {
1803 // Set up SSL context.
1804 auto sslContext = std::make_shared<SSLContext>();
1807 auto socket = MockAsyncTFOSSLSocket::UniquePtr(
1808 new MockAsyncTFOSSLSocket(sslContext, evb));
1809 socket->enableTFO();
1811 EXPECT_CALL(*socket, tfoSendMsg(_, _, _))
1813 .WillOnce(Invoke([&](int fd, struct msghdr*, int) {
1814 sockaddr_storage addr;
1815 auto len = address.getAddress(&addr);
1816 return connect(fd, (const struct sockaddr*)&addr, len);
1821 TEST(AsyncSSLSocketTest, ConnectWriteReadCloseTFOFallback) {
1822 // Start listening on a local port
1823 WriteCallbackBase writeCallback;
1824 ReadCallback readCallback(&writeCallback);
1825 HandshakeCallback handshakeCallback(&readCallback);
1826 SSLServerAcceptCallback acceptCallback(&handshakeCallback);
1827 TestSSLServer server(&acceptCallback, true);
1831 auto socket = setupSocketWithFallback(&evb, server.getAddress(), 1);
1833 socket->connect(&ccb, server.getAddress(), 30);
1836 EXPECT_EQ(ConnCallback::State::SUCCESS, ccb.state);
1838 evb.runInEventBaseThread([&] { socket->detachEventBase(); });
1841 BlockingSocket sock(std::move(socket));
1843 std::array<uint8_t, 128> buf;
1844 memset(buf.data(), 'a', buf.size());
1845 sock.write(buf.data(), buf.size());
1848 std::array<uint8_t, 128> readbuf;
1849 uint32_t bytesRead = sock.readAll(readbuf.data(), readbuf.size());
1850 EXPECT_EQ(bytesRead, 128);
1851 EXPECT_EQ(memcmp(buf.data(), readbuf.data(), bytesRead), 0);
1857 TEST(AsyncSSLSocketTest, ConnectTFOTimeout) {
1858 // Start listening on a local port
1859 ConnectTimeoutCallback acceptCallback;
1860 TestSSLServer server(&acceptCallback, true);
1862 // Set up SSL context.
1863 auto sslContext = std::make_shared<SSLContext>();
1867 std::make_shared<BlockingSocket>(server.getAddress(), sslContext);
1868 socket->enableTFO();
1870 socket->open(std::chrono::milliseconds(1)), AsyncSocketException);
1873 TEST(AsyncSSLSocketTest, ConnectTFOFallbackTimeout) {
1874 // Start listening on a local port
1875 ConnectTimeoutCallback acceptCallback;
1876 TestSSLServer server(&acceptCallback, true);
1880 auto socket = setupSocketWithFallback(&evb, server.getAddress(), AtMost(1));
1882 // Set a short timeout
1883 socket->connect(&ccb, server.getAddress(), 1);
1886 EXPECT_EQ(ConnCallback::State::ERROR, ccb.state);
1894 ///////////////////////////////////////////////////////////////////////////
1895 // init_unit_test_suite
1896 ///////////////////////////////////////////////////////////////////////////
1898 struct Initializer {
1900 signal(SIGPIPE, SIG_IGN);
1903 Initializer initializer;