zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

This changeset adds dependency injection support for SSL Root Certs.

Browse Source 
This extends the API surface so that
custom certificates can be provided by an API user in both the standalone and
factory creation paths for the OpenSSLAdapter. Prior to this change the SSL
roots were hardcoded in a header file and directly included into
openssladapter.cc. This forces the 100 kilobytes of certificates to always be
compiled into the library. This is undesirable in certain linking cases where
these certificates can be shared from another binary that already has an
equivalent set of trusted roots hard coded into the binary.

Support for removing the hard coded SSL roots has also been added through a new
build flag. By default the hard coded SSL roots will be included and will be
used if no other trusted root certificates are provided.

The main goal of this CL is to reduce total binary size requirements of WebRTC
by about 100kb in certain applications where adding these certificates is
redundant.

Change-Id: Ifd36d92b5cb32d1b3098a61ddfc244d76df8f30f

Bug: chromium:526260
Change-Id: Ifd36d92b5cb32d1b3098a61ddfc244d76df8f30f
Reviewed-on: https://webrtc-review.googlesource.com/64841
Commit-Queue: Benjamin Wright <benwright@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23180}
This commit is contained in:
Benjamin Wright
2018-05-08 13:12:25 -07:00
committed by Commit Bot
parent 7c682e0c35
commit d6f86e8fca
31 changed files with 1272 additions and 715 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
rtc_base/openssladapter_unittest.cc
View File

@ -12,10 +12,46 @@
#include <string>
#include <vector>
#include "rtc_base/asyncsocket.h"
#include "rtc_base/gunit.h"
#include "rtc_base/openssladapter.h"
#include "rtc_base/ptr_util.h"
#include "test/gmock.h"
namespace rtc {
namespace {
class MockAsyncSocket : public AsyncSocket {
public:
virtual ~MockAsyncSocket() = default;
MOCK_METHOD1(Accept, AsyncSocket*(SocketAddress*));
MOCK_CONST_METHOD0(GetLocalAddress, SocketAddress());
MOCK_CONST_METHOD0(GetRemoteAddress, SocketAddress());
MOCK_METHOD1(Bind, int(const SocketAddress&));
MOCK_METHOD1(Connect, int(const SocketAddress&));
MOCK_METHOD2(Send, int(const void*, size_t));
MOCK_METHOD3(SendTo, int(const void*, size_t, const SocketAddress&));
MOCK_METHOD3(Recv, int(void*, size_t, int64_t*));
MOCK_METHOD4(RecvFrom, int(void*, size_t, SocketAddress*, int64_t*));
MOCK_METHOD1(Listen, int(int));
MOCK_METHOD0(Close, int());
MOCK_CONST_METHOD0(GetError, int());
MOCK_METHOD1(SetError, void(int));
MOCK_CONST_METHOD0(GetState, ConnState());
MOCK_METHOD2(GetOption, int(Option, int*));
MOCK_METHOD2(SetOption, int(Option, int));
};
class MockCertVerifier : public SSLCertificateVerifier {
public:
virtual ~MockCertVerifier() = default;
MOCK_METHOD1(Verify, bool(const SSLCertificate&));
};
} // namespace
using ::testing::_;
using ::testing::Return;
TEST(OpenSSLAdapterTest, TestTransformAlpnProtocols) {
EXPECT_EQ("", TransformAlpnProtocols(std::vector<std::string>()));
@ -38,4 +74,36 @@ TEST(OpenSSLAdapterTest, TestTransformAlpnProtocols) {
EXPECT_EQ(expected_response.str(), TransformAlpnProtocols(alpn_protos));
}
// Verifies that SSLStart works when OpenSSLAdapter is started in standalone
// mode.
TEST(OpenSSLAdapterTest, TestBeginSSLBeforeConnection) {
AsyncSocket* async_socket = new MockAsyncSocket();
OpenSSLAdapter adapter(async_socket);
EXPECT_EQ(adapter.StartSSL("webrtc.org", false), 0);
}
// Verifies that the adapter factory can create new adapters.
TEST(OpenSSLAdapterFactoryTest, CreateSingleOpenSSLAdapter) {
OpenSSLAdapterFactory adapter_factory;
AsyncSocket* async_socket = new MockAsyncSocket();
auto simple_adapter = std::unique_ptr<OpenSSLAdapter>(
adapter_factory.CreateAdapter(async_socket));
EXPECT_NE(simple_adapter, nullptr);
}
// Verifies that setting a custom verifier still allows for adapters to be
// created.
TEST(OpenSSLAdapterFactoryTest, CreateWorksWithCustomVerifier) {
MockCertVerifier* mock_verifier = new MockCertVerifier();
EXPECT_CALL(*mock_verifier, Verify(_)).WillRepeatedly(Return(true));
auto cert_verifier = std::unique_ptr<SSLCertificateVerifier>(mock_verifier);
OpenSSLAdapterFactory adapter_factory;
adapter_factory.SetCertVerifier(cert_verifier.get());
AsyncSocket* async_socket = new MockAsyncSocket();
auto simple_adapter = std::unique_ptr<OpenSSLAdapter>(
adapter_factory.CreateAdapter(async_socket));
EXPECT_NE(simple_adapter, nullptr);
}
} // namespace rtc