From 7d754441efb46a907e6f20f19c2bbccbcb177e98 Mon Sep 17 00:00:00 2001 From: Valerii Date: Thu, 22 Mar 2018 14:55:37 +0200 Subject: Fix security manager UT Fixed UT which failed due to code changes provided by dtls encryption support by SDL The following UT were fixed: - src/components/security_manager/test/crypto_manager_impl_test.cc - src/components/security_manager/test/security_manager_test.cc - src/components/security_manager/test/ssl_certificate_handshake_test.cc - src/components/security_manager/test/ssl_context_test.cc Conflicts: src/components/security_manager/test/security_manager_test.cc --- .../security_manager/src/crypto_manager_impl.cc | 2 +- .../test/crypto_manager_impl_test.cc | 38 ++-- .../security_manager/test/security_manager_test.cc | 159 +++++++------- .../test/ssl_certificate_handshake_test.cc | 233 +++++++++++---------- .../security_manager/test/ssl_context_test.cc | 174 ++++++++------- 5 files changed, 337 insertions(+), 269 deletions(-) diff --git a/src/components/security_manager/src/crypto_manager_impl.cc b/src/components/security_manager/src/crypto_manager_impl.cc index d83c84bf40..f5908f8043 100644 --- a/src/components/security_manager/src/crypto_manager_impl.cc +++ b/src/components/security_manager/src/crypto_manager_impl.cc @@ -163,7 +163,7 @@ bool CryptoManagerImpl::Init() { #if OPENSSL_VERSION_NUMBER < CONST_SSL_METHOD_MINIMAL_VERSION SSL_METHOD* method; #else - const SSL_METHOD* method; + const SSL_METHOD* method = NULL; #endif switch (get_settings().security_manager_protocol_name()) { case SSLv3: diff --git a/src/components/security_manager/test/crypto_manager_impl_test.cc b/src/components/security_manager/test/crypto_manager_impl_test.cc index fb645b175d..ddc1bb67c5 100644 --- a/src/components/security_manager/test/crypto_manager_impl_test.cc +++ b/src/components/security_manager/test/crypto_manager_impl_test.cc @@ -52,7 +52,8 @@ namespace { const size_t kUpdatesBeforeHour = 24; const std::string kAllCiphers = "ALL"; const std::string kCaCertPath = ""; - +const uint32_t kServiceNumber = 2u; +const size_t kMaxSizeVector = 1u; #ifdef __QNXNTO__ const std::string kFordCipher = SSL3_TXT_RSA_DES_192_CBC3_SHA; #else @@ -89,6 +90,8 @@ class CryptoManagerTest : public testing::Test { utils::MakeShared(); crypto_manager_ = utils::MakeShared(mock_security_manager_settings_); + forced_protected_services_.reserve(kMaxSizeVector); + forced_unprotected_services_.reserve(kMaxSizeVector); } void InitSecurityManager() { @@ -101,6 +104,10 @@ class CryptoManagerTest : public testing::Test { void SetInitialValues(security_manager::Mode mode, security_manager::Protocol protocol, const std::string& cipher) { + ON_CALL(*mock_security_manager_settings_, force_unprotected_service()) + .WillByDefault(ReturnRef(forced_unprotected_services_)); + ON_CALL(*mock_security_manager_settings_, force_protected_service()) + .WillByDefault(ReturnRef(forced_protected_services_)); ON_CALL(*mock_security_manager_settings_, security_manager_mode()) .WillByDefault(Return(mode)); ON_CALL(*mock_security_manager_settings_, security_manager_protocol_name()) @@ -118,6 +125,8 @@ class CryptoManagerTest : public testing::Test { utils::SharedPtr crypto_manager_; utils::SharedPtr mock_security_manager_settings_; static std::string certificate_data_base64_; + std::vector forced_protected_services_; + std::vector forced_unprotected_services_; }; std::string CryptoManagerTest::certificate_data_base64_; @@ -128,21 +137,26 @@ TEST_F(CryptoManagerTest, UsingBeforeInit) { } TEST_F(CryptoManagerTest, WrongInit) { - // We have to cast (-1) to security_manager::Protocol Enum to be accepted by - // crypto_manager_->Init(...) - // Unknown protocol version - security_manager::Protocol UNKNOWN = - static_cast(-1); - + forced_protected_services_.push_back(kServiceNumber); + forced_unprotected_services_.push_back(kServiceNumber); EXPECT_CALL(*mock_security_manager_settings_, security_manager_mode()) - .WillRepeatedly(Return(security_manager::SERVER)); - EXPECT_CALL(*mock_security_manager_settings_, - security_manager_protocol_name()).WillOnce(Return(UNKNOWN)); + .WillOnce(Return(security_manager::SERVER)); + EXPECT_CALL(*mock_security_manager_settings_, force_unprotected_service()) + .WillOnce(ReturnRef(forced_unprotected_services_)); + EXPECT_CALL(*mock_security_manager_settings_, force_protected_service()) + .WillOnce(ReturnRef(forced_protected_services_)); EXPECT_FALSE(crypto_manager_->Init()); - + forced_protected_services_.pop_back(); + forced_unprotected_services_.pop_back(); EXPECT_NE(std::string(), crypto_manager_->LastError()); // Unexistent cipher value const std::string invalid_cipher = "INVALID_UNKNOWN_CIPHER"; + EXPECT_CALL(*mock_security_manager_settings_, security_manager_mode()) + .WillOnce(Return(security_manager::SERVER)); + EXPECT_CALL(*mock_security_manager_settings_, force_unprotected_service()) + .WillOnce(ReturnRef(forced_unprotected_services_)); + EXPECT_CALL(*mock_security_manager_settings_, force_protected_service()) + .WillOnce(ReturnRef(forced_protected_services_)); EXPECT_CALL(*mock_security_manager_settings_, security_manager_protocol_name()) .WillOnce(Return(security_manager::TLSv1_2)); @@ -151,7 +165,6 @@ TEST_F(CryptoManagerTest, WrongInit) { EXPECT_CALL(*mock_security_manager_settings_, ciphers_list()) .WillRepeatedly(ReturnRef(invalid_cipher)); EXPECT_FALSE(crypto_manager_->Init()); - EXPECT_NE(std::string(), crypto_manager_->LastError()); } @@ -198,7 +211,6 @@ TEST_F(CryptoManagerTest, CreateReleaseSSLContext) { EXPECT_CALL(*mock_security_manager_settings_, maximum_payload_size()) .Times(1) .WillRepeatedly(Return(max_payload_size)); - security_manager::SSLContext* context = crypto_manager_->CreateSSLContext(); EXPECT_TRUE(context); EXPECT_NO_THROW(crypto_manager_->ReleaseSSLContext(context)); diff --git a/src/components/security_manager/test/security_manager_test.cc b/src/components/security_manager/test/security_manager_test.cc index 4fe66498ea..2661d9fef4 100644 --- a/src/components/security_manager/test/security_manager_test.cc +++ b/src/components/security_manager/test/security_manager_test.cc @@ -77,11 +77,11 @@ using ::testing::_; namespace { // Sample data for handshake data emulation -const int32_t key = 0x1; -const int32_t seq_number = 0x2; -const ServiceType secureServiceType = kControl; -const uint32_t protocolVersion = PROTOCOL_VERSION_2; -const bool is_final = false; +const int32_t kKey = 0x1; +const int32_t kSeqNumber = 0x2; +const ServiceType kSecureServiceType = kControl; +const uint32_t kProtocolVersion = PROTOCOL_VERSION_2; +const bool kIsFinal = false; const uint8_t handshake_data[] = {0x1, 0x2, 0x3, 0x4, 0x5}; const size_t handshake_data_size = @@ -121,7 +121,7 @@ class SecurityManagerTest : public ::testing::Test { uint32_t dataSize, const ServiceType serviceType) { const RawMessagePtr rawMessagePtr(utils::MakeShared( - key, protocolVersion, data, dataSize, serviceType)); + kKey, kProtocolVersion, data, dataSize, serviceType)); security_manager_->OnMessageReceived(rawMessagePtr); } /* @@ -152,7 +152,7 @@ class SecurityManagerTest : public ::testing::Test { const int repeat_count = 1) { const SecurityQuery::QueryHeader header(SecurityQuery::NOTIFICATION, SecurityQuery::SEND_HANDSHAKE_DATA, - seq_number); + kSeqNumber); for (int c = 0; c < repeat_count; ++c) { EmulateMobileMessage(header, data, data_size); } @@ -216,9 +216,9 @@ TEST_F(SecurityManagerTest, Listeners_NoListeners) { security_manager_->RemoveListener(&mock_listener2); security_manager_->NotifyListenersOnHandshakeDone( - key, SSLContext::Handshake_Result_Success); + kKey, SSLContext::Handshake_Result_Success); security_manager_->NotifyListenersOnHandshakeDone( - key, SSLContext::Handshake_Result_Fail); + kKey, SSLContext::Handshake_Result_Fail); } /* * Notifying two listeners @@ -235,11 +235,11 @@ TEST_F(SecurityManagerTest, Listeners_Notifying) { const SSLContext::HandshakeResult first_call_value = SSLContext::Handshake_Result_Success; // Expect call both listeners on 1st call - EXPECT_CALL(*mock_listener1, OnHandshakeDone(key, first_call_value)) + EXPECT_CALL(*mock_listener1, OnHandshakeDone(kKey, first_call_value)) . // Emulate false (reject) result WillOnce(Return(false)); - EXPECT_CALL(*mock_listener2, OnHandshakeDone(key, first_call_value)) + EXPECT_CALL(*mock_listener2, OnHandshakeDone(kKey, first_call_value)) . // Emulate true (accept) result WillOnce(Return(true)); @@ -251,7 +251,7 @@ TEST_F(SecurityManagerTest, Listeners_Notifying) { const SSLContext::HandshakeResult second_call_value = SSLContext::Handshake_Result_Fail; // Expect call last listener on 2d call - EXPECT_CALL(*mock_listener1, OnHandshakeDone(key, second_call_value)) + EXPECT_CALL(*mock_listener1, OnHandshakeDone(kKey, second_call_value)) . // Emulate false (reject) result WillOnce(Return(true)); @@ -261,14 +261,14 @@ TEST_F(SecurityManagerTest, Listeners_Notifying) { security_manager_->AddListener(mock_listener1); security_manager_->AddListener(mock_listener2); // 1st call - security_manager_->NotifyListenersOnHandshakeDone(key, first_call_value); + security_manager_->NotifyListenersOnHandshakeDone(kKey, first_call_value); security_manager_->NotifyOnCertificateUpdateRequired(); // 2nd call - security_manager_->NotifyListenersOnHandshakeDone(key, second_call_value); + security_manager_->NotifyListenersOnHandshakeDone(kKey, second_call_value); security_manager_->NotifyOnCertificateUpdateRequired(); // 3nd call security_manager_->NotifyListenersOnHandshakeDone( - key, SSLContext::Handshake_Result_Fail); + kKey, SSLContext::Handshake_Result_Fail); security_manager_->NotifyOnCertificateUpdateRequired(); } @@ -282,7 +282,7 @@ TEST_F(SecurityManagerTest, SecurityManager_NULLCryptoManager) { uint8_t session_id = 0; TestAsyncWaiter waiter; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)); + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)); EXPECT_CALL(mock_session_observer, ProtocolVersionUsed(connection_id, session_id, _)) .WillOnce(Return(true)); @@ -290,7 +290,7 @@ TEST_F(SecurityManagerTest, SecurityManager_NULLCryptoManager) { EXPECT_CALL(mock_protocol_handler, SendMessageToMobileApp( InternalErrorWithErrId(SecurityManager::ERROR_NOT_SUPPORTED), - is_final)).WillOnce(NotifyTestAsyncWaiter(&waiter)); + kIsFinal)).WillOnce(NotifyTestAsyncWaiter(&waiter)); const SecurityQuery::QueryHeader header(SecurityQuery::REQUEST, // It could be any query id SecurityQuery::INVALID_QUERY_ID); @@ -305,7 +305,7 @@ TEST_F(SecurityManagerTest, SecurityManager_NULLCryptoManager) { TEST_F(SecurityManagerTest, OnMobileMessageSent) { const uint8_t* data_param = NULL; const RawMessagePtr rawMessagePtr( - utils::MakeShared(key, protocolVersion, data_param, 0)); + utils::MakeShared(kKey, kProtocolVersion, data_param, 0)); security_manager_->OnMobileMessageSent(rawMessagePtr); } /* @@ -326,7 +326,7 @@ TEST_F(SecurityManagerTest, GetEmptyQuery) { uint32_t connection_id = 0; uint8_t session_id = 0; // uint8_t protocol_version = 0; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)); + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)); EXPECT_CALL(mock_session_observer, ProtocolVersionUsed(connection_id, session_id, _)) .WillOnce(Return(true)); @@ -335,9 +335,9 @@ TEST_F(SecurityManagerTest, GetEmptyQuery) { mock_protocol_handler, SendMessageToMobileApp( InternalErrorWithErrId(SecurityManager::ERROR_INVALID_QUERY_SIZE), - is_final)); + kIsFinal)); // Call with NULL data - call_OnMessageReceived(NULL, 0, secureServiceType); + call_OnMessageReceived(NULL, 0, kSecureServiceType); } /* * Shall send InternallError on null data recieved @@ -347,7 +347,7 @@ TEST_F(SecurityManagerTest, GetWrongJSONSize) { uint32_t connection_id = 0; uint8_t session_id = 0; // uint8_t protocol_version = 0; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)); + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)); EXPECT_CALL(mock_session_observer, ProtocolVersionUsed(connection_id, session_id, _)) .WillOnce(Return(true)); @@ -356,7 +356,7 @@ TEST_F(SecurityManagerTest, GetWrongJSONSize) { mock_protocol_handler, SendMessageToMobileApp( InternalErrorWithErrId(SecurityManager::ERROR_INVALID_QUERY_SIZE), - is_final)); + kIsFinal)); SecurityQuery::QueryHeader header(SecurityQuery::REQUEST, SecurityQuery::INVALID_QUERY_ID); header.json_size = 0x0FFFFFFF; @@ -372,7 +372,7 @@ TEST_F(SecurityManagerTest, GetInvalidQueryId) { TestAsyncWaiter waiter; uint32_t times = 0; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)) + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)) .WillOnce(NotifyTestAsyncWaiter(&waiter)); times++; EXPECT_CALL(mock_session_observer, @@ -385,7 +385,7 @@ TEST_F(SecurityManagerTest, GetInvalidQueryId) { mock_protocol_handler, SendMessageToMobileApp( InternalErrorWithErrId(SecurityManager::ERROR_INVALID_QUERY_ID), - is_final)).WillOnce(NotifyTestAsyncWaiter(&waiter)); + kIsFinal)).WillOnce(NotifyTestAsyncWaiter(&waiter)); times++; const SecurityQuery::QueryHeader header(SecurityQuery::REQUEST, SecurityQuery::INVALID_QUERY_ID); @@ -402,11 +402,11 @@ TEST_F(SecurityManagerTest, CreateSSLContext_ServiceAlreadyProtected) { SetMockCryptoManager(); // Return mock SSLContext - EXPECT_CALL(mock_session_observer, GetSSLContext(key, kControl)) + EXPECT_CALL(mock_session_observer, GetSSLContext(kKey, kControl)) .WillOnce(Return(&mock_ssl_context_new)); const SSLContext* result = security_manager_->CreateSSLContext( - key, + kKey, security_manager::SecurityManager::ContextCreationStrategy::kUseExisting); EXPECT_EQ(&mock_ssl_context_new, result); } @@ -419,22 +419,22 @@ TEST_F(SecurityManagerTest, CreateSSLContext_ErrorCreateSSL) { uint32_t connection_id = 0; uint8_t session_id = 0; // uint8_t protocol_version = 0; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)); + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)); EXPECT_CALL(mock_session_observer, ProtocolVersionUsed(connection_id, session_id, _)) .WillOnce(Return(true)); EXPECT_CALL( mock_protocol_handler, SendMessageToMobileApp( - InternalErrorWithErrId(SecurityManager::ERROR_INTERNAL), is_final)); + InternalErrorWithErrId(SecurityManager::ERROR_INTERNAL), kIsFinal)); // Emulate SessionObserver and CryptoManager result - EXPECT_CALL(mock_session_observer, GetSSLContext(key, kControl)) + EXPECT_CALL(mock_session_observer, GetSSLContext(kKey, kControl)) .WillOnce(ReturnNull()); EXPECT_CALL(mock_crypto_manager, CreateSSLContext()).WillOnce(ReturnNull()); const SSLContext* result = security_manager_->CreateSSLContext( - key, + kKey, security_manager::SecurityManager::ContextCreationStrategy::kUseExisting); EXPECT_EQ(NULL, result); } @@ -448,7 +448,7 @@ TEST_F(SecurityManagerTest, CreateSSLContext_SetSSLContextError) { uint32_t connection_id = 0; uint8_t session_id = 0; // uint8_t protocol_version = 0; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)); + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)); EXPECT_CALL(mock_session_observer, ProtocolVersionUsed(connection_id, session_id, _)) .WillOnce(Return(true)); @@ -457,19 +457,19 @@ TEST_F(SecurityManagerTest, CreateSSLContext_SetSSLContextError) { mock_protocol_handler, SendMessageToMobileApp( InternalErrorWithErrId(SecurityManager::ERROR_UNKNOWN_INTERNAL_ERROR), - is_final)); + kIsFinal)); // Emulate SessionObserver and CryptoManager result - EXPECT_CALL(mock_session_observer, GetSSLContext(key, kControl)) + EXPECT_CALL(mock_session_observer, GetSSLContext(kKey, kControl)) .WillOnce(ReturnNull()); EXPECT_CALL(mock_crypto_manager, CreateSSLContext()) .WillOnce(Return(&mock_ssl_context_new)); EXPECT_CALL(mock_crypto_manager, ReleaseSSLContext(&mock_ssl_context_new)); - EXPECT_CALL(mock_session_observer, SetSSLContext(key, &mock_ssl_context_new)) + EXPECT_CALL(mock_session_observer, SetSSLContext(kKey, &mock_ssl_context_new)) .WillOnce(Return(SecurityManager::ERROR_UNKNOWN_INTERNAL_ERROR)); const SSLContext* result = security_manager_->CreateSSLContext( - key, + kKey, security_manager::SecurityManager::ContextCreationStrategy::kUseExisting); EXPECT_EQ(NULL, result); } @@ -482,17 +482,18 @@ TEST_F(SecurityManagerTest, CreateSSLContext_Success) { // Expect no notifying listeners - it will be done after handshake // Emulate SessionObserver and CryptoManager result - EXPECT_CALL(mock_session_observer, GetSSLContext(key, kControl)) + EXPECT_CALL(mock_session_observer, GetSSLContext(kKey, kControl)) + .WillOnce(ReturnNull()) . // additional check for debug code WillOnce(Return(&mock_ssl_context_exists)); EXPECT_CALL(mock_crypto_manager, CreateSSLContext()) .WillOnce(Return(&mock_ssl_context_new)); - EXPECT_CALL(mock_session_observer, SetSSLContext(key, &mock_ssl_context_new)) + EXPECT_CALL(mock_session_observer, SetSSLContext(kKey, &mock_ssl_context_new)) .WillOnce(Return(SecurityManager::ERROR_SUCCESS)); const SSLContext* result = security_manager_->CreateSSLContext( - key, + kKey, security_manager::SecurityManager::ContextCreationStrategy:: kForceRecreation); EXPECT_EQ(&mock_ssl_context_new, result); @@ -505,7 +506,7 @@ TEST_F(SecurityManagerTest, StartHandshake_ServiceStillUnprotected) { uint32_t connection_id = 0; uint8_t session_id = 0; // uint8_t protocol_version = 0; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)); + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)); EXPECT_CALL(mock_session_observer, ProtocolVersionUsed(connection_id, session_id, _)) .WillOnce(Return(true)); @@ -513,17 +514,17 @@ TEST_F(SecurityManagerTest, StartHandshake_ServiceStillUnprotected) { EXPECT_CALL( mock_protocol_handler, SendMessageToMobileApp( - InternalErrorWithErrId(SecurityManager::ERROR_INTERNAL), is_final)); + InternalErrorWithErrId(SecurityManager::ERROR_INTERNAL), kIsFinal)); // Expect notifying listeners (unsuccess) EXPECT_CALL(*mock_sm_listener, - OnHandshakeDone(key, SSLContext::Handshake_Result_Fail)) + OnHandshakeDone(kKey, SSLContext::Handshake_Result_Fail)) .WillOnce(Return(true)); // Emulate SessionObserver result - EXPECT_CALL(mock_session_observer, GetSSLContext(key, kControl)) + EXPECT_CALL(mock_session_observer, GetSSLContext(kKey, kControl)) .WillOnce(ReturnNull()); - security_manager_->StartHandshake(key); + security_manager_->StartHandshake(kKey); // Listener was destroyed after OnHandshakeDone call mock_sm_listener.release(); @@ -536,24 +537,38 @@ TEST_F(SecurityManagerTest, StartHandshake_SSLInternalError) { uint32_t connection_id = 0; uint8_t session_id = 0; - - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)); + // uint8_t protocol_version = 0; + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)); + EXPECT_CALL(mock_session_observer, GetHandshakeContext(kKey)) + .WillOnce(Return(SSLContext::HandshakeContext())); EXPECT_CALL(mock_session_observer, ProtocolVersionUsed(connection_id, session_id, _)) .WillOnce(Return(true)); - // Expect notifying listeners (unsuccess) - EXPECT_CALL(*mock_sm_listener, - OnHandshakeDone(key, SSLContext::Handshake_Result_Fail)) - .WillOnce(Return(true)); - EXPECT_CALL(mock_session_observer, GetSSLContext(key, kControl)) - .WillOnce(ReturnNull()); + // Expect InternalError with ERROR_ID EXPECT_CALL( mock_protocol_handler, SendMessageToMobileApp( - InternalErrorWithErrId(SecurityManager::ERROR_INTERNAL), is_final)); + InternalErrorWithErrId(SecurityManager::ERROR_INTERNAL), kIsFinal)); + // Expect notifying listeners (unsuccess) + EXPECT_CALL(*mock_sm_listener, + OnHandshakeDone(kKey, SSLContext::Handshake_Result_Fail)) + .WillOnce(Return(true)); + + // Emulate SessionObserver result + EXPECT_CALL(mock_session_observer, GetSSLContext(kKey, kControl)) + .WillOnce(Return(&mock_ssl_context_exists)); + EXPECT_CALL(mock_ssl_context_exists, IsInitCompleted()) + .WillOnce(Return(false)); + EXPECT_CALL(mock_ssl_context_exists, SetHandshakeContext(_)); + EXPECT_CALL(mock_ssl_context_exists, StartHandshake(_, _)) + .WillOnce(DoAll(SetArgPointee<0>(handshake_data_out_pointer), + SetArgPointee<1>(handshake_data_out_size), + Return(SSLContext::Handshake_Result_Fail))); - security_manager_->StartHandshake(key); + security_manager_->StartHandshake(kKey); + + // Listener was destroyed after OnHandshakeDone call mock_sm_listener.release(); } @@ -567,7 +582,7 @@ TEST_F(SecurityManagerTest, ProccessHandshakeData_WrongDataSize) { uint8_t session_id = 0; TestAsyncWaiter waiter; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)); + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)); EXPECT_CALL(mock_session_observer, ProtocolVersionUsed(connection_id, session_id, _)) .WillOnce(Return(true)); @@ -577,7 +592,7 @@ TEST_F(SecurityManagerTest, ProccessHandshakeData_WrongDataSize) { mock_protocol_handler, SendMessageToMobileApp( InternalErrorWithErrId(SecurityManager::ERROR_INVALID_QUERY_SIZE), - is_final)).WillOnce(NotifyTestAsyncWaiter(&waiter)); + kIsFinal)).WillOnce(NotifyTestAsyncWaiter(&waiter)); EmulateMobileMessageHandshake(NULL, 0); @@ -597,7 +612,7 @@ TEST_F(SecurityManagerTest, TestAsyncWaiter waiter; uint32_t times = 0; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)) + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)) .WillOnce(NotifyTestAsyncWaiter(&waiter)); times++; EXPECT_CALL(mock_session_observer, @@ -608,17 +623,17 @@ TEST_F(SecurityManagerTest, mock_protocol_handler, SendMessageToMobileApp( InternalErrorWithErrId(SecurityManager::ERROR_SERVICE_NOT_PROTECTED), - is_final)).WillOnce(NotifyTestAsyncWaiter(&waiter)); + kIsFinal)).WillOnce(NotifyTestAsyncWaiter(&waiter)); times++; // Expect notifying listeners (unsuccess) EXPECT_CALL(*mock_sm_listener, - OnHandshakeDone(key, SSLContext::Handshake_Result_Fail)) + OnHandshakeDone(kKey, SSLContext::Handshake_Result_Fail)) .WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(true))); times++; // Emulate SessionObserver result - EXPECT_CALL(mock_session_observer, GetSSLContext(key, kControl)) + EXPECT_CALL(mock_session_observer, GetSSLContext(kKey, kControl)) .WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), ReturnNull())); times++; @@ -646,7 +661,7 @@ TEST_F(SecurityManagerTest, ProccessHandshakeData_InvalidData) { TestAsyncWaiter waiter; uint32_t times = 0; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)) + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)) .Times(handshake_emulates) .WillRepeatedly(NotifyTestAsyncWaiter(&waiter)); times += handshake_emulates; @@ -661,18 +676,18 @@ TEST_F(SecurityManagerTest, ProccessHandshakeData_InvalidData) { mock_protocol_handler, SendMessageToMobileApp( InternalErrorWithErrId(SecurityManager::ERROR_SSL_INVALID_DATA), - is_final)) + kIsFinal)) .Times(handshake_emulates) .WillRepeatedly(NotifyTestAsyncWaiter(&waiter)); times += handshake_emulates; // Expect notifying listeners (unsuccess) EXPECT_CALL(*mock_sm_listener, - OnHandshakeDone(key, SSLContext::Handshake_Result_Fail)) + OnHandshakeDone(kKey, SSLContext::Handshake_Result_Fail)) .WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(true))); times++; // Emulate SessionObserver and CryptoManager result - EXPECT_CALL(mock_session_observer, GetSSLContext(key, kControl)) + EXPECT_CALL(mock_session_observer, GetSSLContext(kKey, kControl)) .Times(handshake_emulates) .WillRepeatedly(Return(&mock_ssl_context_exists)); @@ -727,7 +742,7 @@ TEST_F(SecurityManagerTest, ProccessHandshakeData_Answer) { TestAsyncWaiter waiter; uint32_t times = 0; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)) + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)) .Times(handshake_emulates) .WillRepeatedly(NotifyTestAsyncWaiter(&waiter)); times += handshake_emulates; @@ -741,14 +756,14 @@ TEST_F(SecurityManagerTest, ProccessHandshakeData_Answer) { const size_t raw_message_size = 15; EXPECT_CALL( mock_protocol_handler, - SendMessageToMobileApp(RawMessageEqSize(raw_message_size), is_final)) + SendMessageToMobileApp(RawMessageEqSize(raw_message_size), kIsFinal)) .Times(handshake_emulates) .WillRepeatedly(NotifyTestAsyncWaiter(&waiter)); times += handshake_emulates; // Expect notifying listeners (unsuccess) EXPECT_CALL(*mock_sm_listener, - OnHandshakeDone(key, SSLContext::Handshake_Result_Fail)) + OnHandshakeDone(kKey, SSLContext::Handshake_Result_Fail)) .WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(true))); times++; @@ -757,7 +772,7 @@ TEST_F(SecurityManagerTest, ProccessHandshakeData_Answer) { .Times(handshake_emulates) .WillRepeatedly(DoAll(NotifyTestAsyncWaiter(&waiter), Return(false))); times += handshake_emulates; - EXPECT_CALL(mock_session_observer, GetSSLContext(key, kControl)) + EXPECT_CALL(mock_session_observer, GetSSLContext(kKey, kControl)) .Times(handshake_emulates) .WillRepeatedly(DoAll(NotifyTestAsyncWaiter(&waiter), Return(&mock_ssl_context_exists))); @@ -803,12 +818,12 @@ TEST_F(SecurityManagerTest, ProccessHandshakeData_HandshakeFinished) { // Expect no errors // Expect notifying listeners (success) EXPECT_CALL(*mock_sm_listener, - OnHandshakeDone(key, SSLContext::Handshake_Result_Success)) + OnHandshakeDone(kKey, SSLContext::Handshake_Result_Success)) .WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(true))); times++; // Emulate SessionObserver and CryptoManager result - EXPECT_CALL(mock_session_observer, GetSSLContext(key, kControl)) + EXPECT_CALL(mock_session_observer, GetSSLContext(kKey, kControl)) .Times(handshake_emulates) .WillRepeatedly(DoAll(NotifyTestAsyncWaiter(&waiter), Return(&mock_ssl_context_exists))); @@ -861,14 +876,14 @@ TEST_F(SecurityManagerTest, ProccessHandshakeData_HandshakeFinished) { uint32_t connection_id = 0; uint8_t session_id = 0; // uint8_t protocol_version = 0; - EXPECT_CALL(mock_session_observer, PairFromKey(key, _, _)).Times(2); + EXPECT_CALL(mock_session_observer, PairFromKey(kKey, _, _)).Times(2); EXPECT_CALL(mock_session_observer, ProtocolVersionUsed(connection_id, session_id, _)) .Times(2) .WillRepeatedly(DoAll(NotifyTestAsyncWaiter(&waiter), Return(true))); times += 2; // matches to the number above - EXPECT_CALL(mock_protocol_handler, SendMessageToMobileApp(_, is_final)) + EXPECT_CALL(mock_protocol_handler, SendMessageToMobileApp(_, kIsFinal)) .Times(2) .WillRepeatedly(NotifyTestAsyncWaiter(&waiter)); times += 2; // matches to the number above diff --git a/src/components/security_manager/test/ssl_certificate_handshake_test.cc b/src/components/security_manager/test/ssl_certificate_handshake_test.cc index dc335c8da2..139c772cf2 100644 --- a/src/components/security_manager/test/ssl_certificate_handshake_test.cc +++ b/src/components/security_manager/test/ssl_certificate_handshake_test.cc @@ -66,36 +66,34 @@ const std::string server_expired_cert_file = const bool verify_peer = true; const bool skip_peer_verification = false; -const size_t updates_before_hour = 24; - } // namespace class SSLHandshakeTest : public testing::Test { protected: void SetUp() OVERRIDE { - mock_server_manager_settings = new testing::NiceMock< + mock_server_manager_settings_ = new testing::NiceMock< security_manager_test::MockCryptoManagerSettings>(); - server_manager = new security_manager::CryptoManagerImpl( + server_manager_ = new security_manager::CryptoManagerImpl( utils::SharedPtr( - mock_server_manager_settings)); - ASSERT_TRUE(server_manager); - mock_client_manager_settings = new testing::NiceMock< + mock_server_manager_settings_)); + ASSERT_TRUE(server_manager_); + mock_client_manager_settings_ = new testing::NiceMock< security_manager_test::MockCryptoManagerSettings>(); - client_manager = new security_manager::CryptoManagerImpl( + client_manager_ = new security_manager::CryptoManagerImpl( utils::SharedPtr( - mock_client_manager_settings)); - ASSERT_TRUE(client_manager); - server_ctx = NULL; - client_ctx = NULL; + mock_client_manager_settings_)); + ASSERT_TRUE(client_manager_); + server_ctx_ = NULL; + client_ctx_ = NULL; } void TearDown() OVERRIDE { - server_manager->ReleaseSSLContext(server_ctx); - delete server_manager; - client_manager->ReleaseSSLContext(client_ctx); - delete client_manager; + server_manager_->ReleaseSSLContext(server_ctx_); + delete server_manager_; + client_manager_->ReleaseSSLContext(client_ctx_); + delete client_manager_; } void SetServerInitialValues(const security_manager::Protocol protocol, @@ -106,18 +104,21 @@ class SSLHandshakeTest : public testing::Test { server_certificate_ = cert; server_ciphers_list_ = server_ciphers_list; server_ca_certificate_path_ = ca_certificate_path; - - ON_CALL(*mock_server_manager_settings, security_manager_mode()) + ON_CALL(*mock_server_manager_settings_, force_unprotected_service()) + .WillByDefault(ReturnRef(forced_unprotected_service_)); + ON_CALL(*mock_server_manager_settings_, force_protected_service()) + .WillByDefault(ReturnRef(forced_protected_service_)); + ON_CALL(*mock_server_manager_settings_, security_manager_mode()) .WillByDefault(Return(security_manager::SERVER)); - ON_CALL(*mock_server_manager_settings, security_manager_protocol_name()) + ON_CALL(*mock_server_manager_settings_, security_manager_protocol_name()) .WillByDefault(Return(protocol)); - ON_CALL(*mock_server_manager_settings, certificate_data()) + ON_CALL(*mock_server_manager_settings_, certificate_data()) .WillByDefault(ReturnRef(server_certificate_)); - ON_CALL(*mock_server_manager_settings, ciphers_list()) + ON_CALL(*mock_server_manager_settings_, ciphers_list()) .WillByDefault(ReturnRef(server_ciphers_list_)); - ON_CALL(*mock_server_manager_settings, ca_cert_path()) + ON_CALL(*mock_server_manager_settings_, ca_cert_path()) .WillByDefault(ReturnRef(server_ca_certificate_path_)); - ON_CALL(*mock_server_manager_settings, verify_peer()) + ON_CALL(*mock_server_manager_settings_, verify_peer()) .WillByDefault(Return(verify_peer)); } void SetClientInitialValues(const security_manager::Protocol protocol, @@ -129,17 +130,21 @@ class SSLHandshakeTest : public testing::Test { client_ciphers_list_ = client_ciphers_list; client_ca_certificate_path_ = ca_certificate_path; - ON_CALL(*mock_client_manager_settings, security_manager_mode()) + ON_CALL(*mock_client_manager_settings_, force_unprotected_service()) + .WillByDefault(ReturnRef(forced_unprotected_service_)); + ON_CALL(*mock_client_manager_settings_, force_protected_service()) + .WillByDefault(ReturnRef(forced_protected_service_)); + ON_CALL(*mock_client_manager_settings_, security_manager_mode()) .WillByDefault(Return(security_manager::CLIENT)); - ON_CALL(*mock_client_manager_settings, security_manager_protocol_name()) + ON_CALL(*mock_client_manager_settings_, security_manager_protocol_name()) .WillByDefault(Return(protocol)); - ON_CALL(*mock_client_manager_settings, certificate_data()) + ON_CALL(*mock_client_manager_settings_, certificate_data()) .WillByDefault(ReturnRef(client_certificate_)); - ON_CALL(*mock_client_manager_settings, ciphers_list()) + ON_CALL(*mock_client_manager_settings_, ciphers_list()) .WillByDefault(ReturnRef(client_ciphers_list_)); - ON_CALL(*mock_client_manager_settings, ca_cert_path()) + ON_CALL(*mock_client_manager_settings_, ca_cert_path()) .WillByDefault(ReturnRef(client_ca_certificate_path_)); - ON_CALL(*mock_client_manager_settings, verify_peer()) + ON_CALL(*mock_client_manager_settings_, verify_peer()) .WillByDefault(Return(verify_peer)); } @@ -156,19 +161,19 @@ class SSLHandshakeTest : public testing::Test { cert.close(); SetServerInitialValues( protocol, ss.str(), ciphers_list, verify_peer, ca_certificate_path); - const bool initialized = server_manager->Init(); + const bool initialized = server_manager_->Init(); if (!initialized) { return false; } - server_ctx = server_manager->CreateSSLContext(); + server_ctx_ = server_manager_->CreateSSLContext(); - if (!server_ctx) { + if (!server_ctx_) { return false; } - server_ctx->SetHandshakeContext( + server_ctx_->SetHandshakeContext( security_manager::SSLContext::HandshakeContext( custom_str::CustomString("SPT"), custom_str::CustomString("client"))); @@ -192,17 +197,17 @@ class SSLHandshakeTest : public testing::Test { ciphers_list, verify_peer, ca_certificate_path); - const bool initialized = client_manager->Init(); + const bool initialized = client_manager_->Init(); if (!initialized) { return false; } - client_ctx = client_manager->CreateSSLContext(); - if (!client_ctx) { + client_ctx_ = client_manager_->CreateSSLContext(); + if (!client_ctx_) { return false; } - client_ctx->SetHandshakeContext( + client_ctx_->SetHandshakeContext( security_manager::SSLContext::HandshakeContext( custom_str::CustomString("SPT"), custom_str::CustomString("server"))); @@ -211,17 +216,17 @@ class SSLHandshakeTest : public testing::Test { } void ResetConnections() { - ASSERT_NO_THROW(server_ctx->ResetConnection()); - ASSERT_NO_THROW(client_ctx->ResetConnection()); + ASSERT_NO_THROW(server_ctx_->ResetConnection()); + ASSERT_NO_THROW(client_ctx_->ResetConnection()); } void StartHandshake() { using security_manager::SSLContext; ASSERT_EQ(SSLContext::Handshake_Result_Success, - client_ctx->StartHandshake(&client_buf, &client_buf_len)); - ASSERT_FALSE(client_buf == NULL); - ASSERT_GT(client_buf_len, 0u); + client_ctx_->StartHandshake(&client_buf_, &client_buf_len_)); + ASSERT_FALSE(client_buf_ == NULL); + ASSERT_GT(client_buf_len_, 0u); } void HandshakeProcedure_Success() { @@ -229,23 +234,25 @@ class SSLHandshakeTest : public testing::Test { StartHandshake(); while (true) { - ASSERT_EQ(SSLContext::Handshake_Result_Success, - server_ctx->DoHandshakeStep( - client_buf, client_buf_len, &server_buf, &server_buf_len)) + ASSERT_EQ( + SSLContext::Handshake_Result_Success, + server_ctx_->DoHandshakeStep( + client_buf_, client_buf_len_, &server_buf_, &server_buf_len_)) << ERR_reason_error_string(ERR_get_error()); - ASSERT_FALSE(server_buf == NULL); - ASSERT_GT(server_buf_len, 0u); + ASSERT_FALSE(server_buf_ == NULL); + ASSERT_GT(server_buf_len_, 0u); - ASSERT_EQ(SSLContext::Handshake_Result_Success, - client_ctx->DoHandshakeStep( - server_buf, server_buf_len, &client_buf, &client_buf_len)) + ASSERT_EQ( + SSLContext::Handshake_Result_Success, + client_ctx_->DoHandshakeStep( + server_buf_, server_buf_len_, &client_buf_, &client_buf_len_)) << ERR_reason_error_string(ERR_get_error()); - if (server_ctx->IsInitCompleted()) { + if (server_ctx_->IsInitCompleted()) { break; } - ASSERT_FALSE(client_buf == NULL); - ASSERT_GT(client_buf_len, 0u); + ASSERT_FALSE(client_buf_ == NULL); + ASSERT_GT(client_buf_len_, 0u); } } @@ -255,9 +262,9 @@ class SSLHandshakeTest : public testing::Test { StartHandshake(); while (true) { - const SSLContext::HandshakeResult result = server_ctx->DoHandshakeStep( - client_buf, client_buf_len, &server_buf, &server_buf_len); - ASSERT_FALSE(server_ctx->IsInitCompleted()) + const SSLContext::HandshakeResult result = server_ctx_->DoHandshakeStep( + client_buf_, client_buf_len_, &server_buf_, &server_buf_len_); + ASSERT_FALSE(server_ctx_->IsInitCompleted()) << "Expected server side handshake fail"; // First few handshake will be successful @@ -265,18 +272,19 @@ class SSLHandshakeTest : public testing::Test { // Test successfully passed with handshake fail return; } - ASSERT_FALSE(server_buf == NULL); - ASSERT_GT(server_buf_len, 0u); + ASSERT_FALSE(server_buf_ == NULL); + ASSERT_GT(server_buf_len_, 0u); - ASSERT_EQ(SSLContext::Handshake_Result_Success, - client_ctx->DoHandshakeStep( - server_buf, server_buf_len, &client_buf, &client_buf_len)) + ASSERT_EQ( + SSLContext::Handshake_Result_Success, + client_ctx_->DoHandshakeStep( + server_buf_, server_buf_len_, &client_buf_, &client_buf_len_)) << ERR_reason_error_string(ERR_get_error()); - ASSERT_FALSE(client_ctx->IsInitCompleted()) + ASSERT_FALSE(client_ctx_->IsInitCompleted()) << "Expected server side handshake fail"; - ASSERT_FALSE(client_buf == NULL); - ASSERT_GT(client_buf_len, 0u); + ASSERT_FALSE(client_buf_ == NULL); + ASSERT_GT(client_buf_len_, 0u); } FAIL() << "Expected server side handshake fail"; } @@ -288,17 +296,18 @@ class SSLHandshakeTest : public testing::Test { StartHandshake(); while (true) { - ASSERT_EQ(SSLContext::Handshake_Result_Success, - server_ctx->DoHandshakeStep( - client_buf, client_buf_len, &server_buf, &server_buf_len)) + ASSERT_EQ( + SSLContext::Handshake_Result_Success, + server_ctx_->DoHandshakeStep( + client_buf_, client_buf_len_, &server_buf_, &server_buf_len_)) << ERR_reason_error_string(ERR_get_error()); - ASSERT_FALSE(server_buf == NULL); - ASSERT_GT(server_buf_len, 0u); + ASSERT_FALSE(server_buf_ == NULL); + ASSERT_GT(server_buf_len_, 0u); - const SSLContext::HandshakeResult result = client_ctx->DoHandshakeStep( - server_buf, server_buf_len, &client_buf, &client_buf_len); - ASSERT_FALSE(client_ctx->IsInitCompleted()) + const SSLContext::HandshakeResult result = client_ctx_->DoHandshakeStep( + server_buf_, server_buf_len_, &client_buf_, &client_buf_len_); + ASSERT_FALSE(client_ctx_->IsInitCompleted()) << "Expected client side handshake fail"; // First few handsahke will be successful @@ -308,25 +317,25 @@ class SSLHandshakeTest : public testing::Test { return; } - ASSERT_FALSE(client_buf == NULL); - ASSERT_GT(client_buf_len, 0u); + ASSERT_FALSE(client_buf_ == NULL); + ASSERT_GT(client_buf_len_, 0u); } FAIL() << "Expected client side handshake fail"; } - security_manager::CryptoManager* server_manager; - security_manager::CryptoManager* client_manager; - security_manager::SSLContext* server_ctx; - security_manager::SSLContext* client_ctx; + security_manager::CryptoManager* server_manager_; + security_manager::CryptoManager* client_manager_; + security_manager::SSLContext* server_ctx_; + security_manager::SSLContext* client_ctx_; testing::NiceMock* - mock_server_manager_settings; + mock_server_manager_settings_; testing::NiceMock* - mock_client_manager_settings; + mock_client_manager_settings_; - const uint8_t* server_buf; - const uint8_t* client_buf; - size_t server_buf_len; - size_t client_buf_len; + const uint8_t* server_buf_; + const uint8_t* client_buf_; + size_t server_buf_len_; + size_t client_buf_len_; std::string server_certificate_; std::string server_ciphers_list_; @@ -335,6 +344,9 @@ class SSLHandshakeTest : public testing::Test { std::string client_certificate_; std::string client_ciphers_list_; std::string client_ca_certificate_path_; + + const std::vector forced_protected_service_; + const std::vector forced_unprotected_service_; }; TEST_F(SSLHandshakeTest, NoVerification) { @@ -343,13 +355,14 @@ TEST_F(SSLHandshakeTest, NoVerification) { "ALL", skip_peer_verification, "")) - << server_manager->LastError(); + << server_manager_->LastError(); + ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, client_certificate, "ALL", skip_peer_verification, "")) - << client_manager->LastError(); + << client_manager_->LastError(); GTEST_TRACE(HandshakeProcedure_Success()); } @@ -360,13 +373,13 @@ TEST_F(SSLHandshakeTest, CAVerification_ServerSide) { "ALL", verify_peer, client_ca_cert_filename)) - << server_manager->LastError(); + << server_manager_->LastError(); ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, client_certificate, "ALL", skip_peer_verification, "")) - << client_manager->LastError(); + << client_manager_->LastError(); GTEST_TRACE(HandshakeProcedure_Success()); } @@ -374,13 +387,13 @@ TEST_F(SSLHandshakeTest, CAVerification_ServerSide) { TEST_F(SSLHandshakeTest, CAVerification_ServerSide_NoCACertificate) { ASSERT_TRUE(InitServerManagers( security_manager::TLSv1_2, "", "ALL", verify_peer, "unex")) - << server_manager->LastError(); + << server_manager_->LastError(); ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, client_certificate, "ALL", skip_peer_verification, "")) - << client_manager->LastError(); + << client_manager_->LastError(); GTEST_TRACE(HandshakeProcedure_ServerSideFail()); ASSERT_TRUE(InitServerManagers(security_manager::TLSv1_2, @@ -388,7 +401,7 @@ TEST_F(SSLHandshakeTest, CAVerification_ServerSide_NoCACertificate) { "ALL", verify_peer, client_ca_cert_filename)) - << server_manager->LastError(); + << server_manager_->LastError(); GTEST_TRACE(ResetConnections()); @@ -401,13 +414,13 @@ TEST_F(SSLHandshakeTest, CAVerification_ClientSide) { "ALL", verify_peer, client_ca_cert_filename)) - << server_manager->LastError(); + << server_manager_->LastError(); ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, client_certificate, "ALL", verify_peer, server_ca_cert_filename)) - << client_manager->LastError(); + << client_manager_->LastError(); GTEST_TRACE(HandshakeProcedure_Success()); } @@ -418,13 +431,13 @@ TEST_F(SSLHandshakeTest, CAVerification_ClientSide_NoCACertificate) { "ALL", skip_peer_verification, "")) - << server_manager->LastError(); + << server_manager_->LastError(); ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, "", "ALL", verify_peer, "client_ca_cert_filename")) - << client_manager->LastError(); + << client_manager_->LastError(); GTEST_TRACE(HandshakeProcedure_ClientSideFail( security_manager::SSLContext::Handshake_Result_Fail)); @@ -434,7 +447,7 @@ TEST_F(SSLHandshakeTest, CAVerification_ClientSide_NoCACertificate) { "ALL", verify_peer, server_ca_cert_filename)) - << client_manager->LastError(); + << client_manager_->LastError(); GTEST_TRACE(ResetConnections()); @@ -447,13 +460,13 @@ TEST_F(SSLHandshakeTest, CAVerification_BothSides) { "ALL", verify_peer, client_ca_cert_filename)) - << server_manager->LastError(); + << server_manager_->LastError(); ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, client_certificate, "ALL", verify_peer, server_ca_cert_filename)) - << client_manager->LastError(); + << client_manager_->LastError(); GTEST_TRACE(HandshakeProcedure_Success()); } @@ -464,13 +477,13 @@ TEST_F(SSLHandshakeTest, UnsignedCert) { "ALL", skip_peer_verification, "")) - << server_manager->LastError(); + << server_manager_->LastError(); ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, client_certificate, "ALL", verify_peer, client_ca_cert_filename)) - << client_manager->LastError(); + << client_manager_->LastError(); GTEST_TRACE(HandshakeProcedure_ClientSideFail( security_manager::SSLContext::Handshake_Result_CertNotSigned)); } @@ -481,13 +494,13 @@ TEST_F(SSLHandshakeTest, ExpiredCert) { "ALL", verify_peer, client_ca_cert_filename)) - << server_manager->LastError(); + << server_manager_->LastError(); ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, client_certificate, "ALL", verify_peer, server_ca_cert_filename)) - << client_manager->LastError(); + << client_manager_->LastError(); GTEST_TRACE(HandshakeProcedure_ClientSideFail( security_manager::SSLContext::Handshake_Result_CertExpired)); @@ -499,15 +512,15 @@ TEST_F(SSLHandshakeTest, AppNameAndAppIDInvalid) { "ALL", verify_peer, client_ca_cert_filename)) - << server_manager->LastError(); + << server_manager_->LastError(); ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, client_certificate, "ALL", verify_peer, server_ca_cert_filename)) - << client_manager->LastError(); + << client_manager_->LastError(); - client_ctx->SetHandshakeContext( + client_ctx_->SetHandshakeContext( security_manager::SSLContext::HandshakeContext( custom_str::CustomString("server"), custom_str::CustomString("Wrong"))); @@ -516,7 +529,7 @@ TEST_F(SSLHandshakeTest, AppNameAndAppIDInvalid) { security_manager::SSLContext::Handshake_Result_AppNameMismatch)); ResetConnections(); - client_ctx->SetHandshakeContext( + client_ctx_->SetHandshakeContext( security_manager::SSLContext::HandshakeContext( custom_str::CustomString("Wrong"), custom_str::CustomString("server"))); @@ -531,13 +544,13 @@ TEST_F(SSLHandshakeTest, NoVerification_ResetConnection) { "ALL", skip_peer_verification, "")) - << server_manager->LastError(); + << server_manager_->LastError(); ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, client_certificate, "ALL", skip_peer_verification, "")) - << client_manager->LastError(); + << client_manager_->LastError(); const int times = 100; for (int i = 0; i < times; ++i) { @@ -555,13 +568,13 @@ TEST_F(SSLHandshakeTest, CAVerification_BothSides_ResetConnection) { "ALL", verify_peer, client_ca_cert_filename)) - << server_manager->LastError(); + << server_manager_->LastError(); ASSERT_TRUE(InitClientManagers(security_manager::TLSv1_2, client_certificate, "ALL", skip_peer_verification, server_ca_cert_filename)) - << client_manager->LastError(); + << client_manager_->LastError(); const int times = 100; for (int i = 0; i < times; ++i) { diff --git a/src/components/security_manager/test/ssl_context_test.cc b/src/components/security_manager/test/ssl_context_test.cc index a77cd98b27..6082a1b62b 100644 --- a/src/components/security_manager/test/ssl_context_test.cc +++ b/src/components/security_manager/test/ssl_context_test.cc @@ -49,7 +49,6 @@ using ::testing::ReturnRef; using ::testing::NiceMock; namespace { -const size_t kUpdatesBeforeHour = 24; const std::string kCaPath = ""; const uint8_t* kServerBuf; const uint8_t* kClientBuf; @@ -70,19 +69,19 @@ namespace ssl_context_test { namespace custom_str = utils::custom_string; struct ProtocolAndCipher { - security_manager::Protocol server_protocol; - security_manager::Protocol client_protocol; - std::string server_ciphers_list; - std::string client_ciphers_list; + security_manager::Protocol server_protocol_; + security_manager::Protocol client_protocol_; + std::string server_ciphers_list_; + std::string client_ciphers_list_; ProtocolAndCipher(security_manager::Protocol s_protocol, security_manager::Protocol c_protocol, std::string s_ciphers_list, std::string c_ciphers_list) - : server_protocol(s_protocol) - , client_protocol(c_protocol) - , server_ciphers_list(s_ciphers_list) - , client_ciphers_list(c_ciphers_list) {} + : server_protocol_(s_protocol) + , client_protocol_(c_protocol) + , server_ciphers_list_(s_ciphers_list) + , client_ciphers_list_(c_ciphers_list) {} }; class SSLTest : public testing::Test { @@ -127,6 +126,12 @@ class SSLTest : public testing::Test { .WillRepeatedly(ReturnRef(kCaPath)); EXPECT_CALL(*mock_crypto_manager_settings_, verify_peer()) .WillOnce(Return(false)); + + ON_CALL(*mock_crypto_manager_settings_, force_unprotected_service()) + .WillByDefault(ReturnRef(forced_unprotected_service_)); + ON_CALL(*mock_crypto_manager_settings_, force_protected_service()) + .WillByDefault(ReturnRef(forced_protected_service_)); + const bool crypto_manager_initialization = crypto_manager_->Init(); EXPECT_TRUE(crypto_manager_initialization); @@ -150,6 +155,12 @@ class SSLTest : public testing::Test { .WillRepeatedly(ReturnRef(kCaPath)); EXPECT_CALL(*mock_client_manager_settings_, verify_peer()) .WillOnce(Return(false)); + + ON_CALL(*mock_client_manager_settings_, force_unprotected_service()) + .WillByDefault(ReturnRef(forced_unprotected_service_)); + ON_CALL(*mock_client_manager_settings_, force_protected_service()) + .WillByDefault(ReturnRef(forced_protected_service_)); + const bool client_manager_initialization = client_manager_->Init(); EXPECT_TRUE(client_manager_initialization); @@ -159,19 +170,19 @@ class SSLTest : public testing::Test { .WillByDefault(Return(kMaximumPayloadSize)); EXPECT_CALL(*mock_crypto_manager_settings_, security_manager_mode()) .WillRepeatedly(Return(security_manager::SERVER)); - server_ctx = crypto_manager_->CreateSSLContext(); + server_ctx_ = crypto_manager_->CreateSSLContext(); EXPECT_CALL(*mock_client_manager_settings_, security_manager_mode()) .Times(2) .WillRepeatedly(Return(security_manager::CLIENT)); - client_ctx = client_manager_->CreateSSLContext(); + client_ctx_ = client_manager_->CreateSSLContext(); using custom_str::CustomString; security_manager::SSLContext::HandshakeContext ctx(CustomString("SPT"), CustomString("client")); - server_ctx->SetHandshakeContext(ctx); + server_ctx_->SetHandshakeContext(ctx); ctx.expected_cn = "server"; - client_ctx->SetHandshakeContext(ctx); + client_ctx_->SetHandshakeContext(ctx); kServerBuf = NULL; kClientBuf = NULL; @@ -180,8 +191,8 @@ class SSLTest : public testing::Test { } void TearDown() OVERRIDE { - crypto_manager_->ReleaseSSLContext(server_ctx); - client_manager_->ReleaseSSLContext(client_ctx); + crypto_manager_->ReleaseSSLContext(server_ctx_); + client_manager_->ReleaseSSLContext(client_ctx_); delete crypto_manager_; delete client_manager_; @@ -194,11 +205,14 @@ class SSLTest : public testing::Test { mock_crypto_manager_settings_; utils::SharedPtr > mock_client_manager_settings_; - security_manager::SSLContext* server_ctx; - security_manager::SSLContext* client_ctx; + security_manager::SSLContext* server_ctx_; + security_manager::SSLContext* client_ctx_; static std::string client_certificate_data_base64_; static std::string server_certificate_data_base64_; + + const std::vector forced_unprotected_service_; + const std::vector forced_protected_service_; }; std::string SSLTest::client_certificate_data_base64_; std::string SSLTest::server_certificate_data_base64_; @@ -222,37 +236,37 @@ class SSLTestParam : public testing::TestWithParam { NiceMock >(); utils::SharedPtr server_crypto( mock_crypto_manager_settings_); - crypto_manager = new security_manager::CryptoManagerImpl(server_crypto); + crypto_manager_ = new security_manager::CryptoManagerImpl(server_crypto); - SetServerInitialValues(GetParam().server_protocol, - GetParam().server_ciphers_list); + SetServerInitialValues(GetParam().server_protocol_, + GetParam().server_ciphers_list_); - const bool crypto_manager_initialization = crypto_manager->Init(); - ASSERT_TRUE(crypto_manager_initialization); + const bool crypto_manager_initialization = crypto_manager_->Init(); + EXPECT_TRUE(crypto_manager_initialization); mock_client_manager_settings_ = utils::MakeShared< NiceMock >(); utils::SharedPtr client_crypto( mock_client_manager_settings_); - client_manager = new security_manager::CryptoManagerImpl(client_crypto); + client_manager_ = new security_manager::CryptoManagerImpl(client_crypto); - SetClientInitialValues(GetParam().client_protocol, - GetParam().client_ciphers_list); + SetClientInitialValues(GetParam().client_protocol_, + GetParam().client_ciphers_list_); - const bool client_manager_initialization = client_manager->Init(); - ASSERT_TRUE(client_manager_initialization); + const bool client_manager_initialization = client_manager_->Init(); + EXPECT_TRUE(client_manager_initialization); - server_ctx = crypto_manager->CreateSSLContext(); - client_ctx = client_manager->CreateSSLContext(); + server_ctx_ = crypto_manager_->CreateSSLContext(); + client_ctx_ = client_manager_->CreateSSLContext(); using custom_str::CustomString; security_manager::SSLContext::HandshakeContext ctx(CustomString("SPT"), CustomString("client")); - server_ctx->SetHandshakeContext(ctx); + server_ctx_->SetHandshakeContext(ctx); ctx.expected_cn = "server"; - client_ctx->SetHandshakeContext(ctx); + client_ctx_->SetHandshakeContext(ctx); kServerBuf = NULL; kClientBuf = NULL; @@ -261,18 +275,19 @@ class SSLTestParam : public testing::TestWithParam { } void TearDown() OVERRIDE { - if (crypto_manager) { - crypto_manager->ReleaseSSLContext(server_ctx); - } - if (client_manager) { - client_manager->ReleaseSSLContext(client_ctx); - } - delete crypto_manager; - delete client_manager; + crypto_manager_->ReleaseSSLContext(server_ctx_); + client_manager_->ReleaseSSLContext(client_ctx_); + + delete crypto_manager_; + delete client_manager_; } void SetServerInitialValues(security_manager::Protocol protocol, const std::string& server_ciphers_list) { + ON_CALL(*mock_crypto_manager_settings_, force_unprotected_service()) + .WillByDefault(ReturnRef(forced_unprotected_service_)); + ON_CALL(*mock_crypto_manager_settings_, force_protected_service()) + .WillByDefault(ReturnRef(forced_protected_service_)); ON_CALL(*mock_crypto_manager_settings_, security_manager_mode()) .WillByDefault(Return(security_manager::SERVER)); ON_CALL(*mock_crypto_manager_settings_, security_manager_protocol_name()) @@ -286,8 +301,13 @@ class SSLTestParam : public testing::TestWithParam { ON_CALL(*mock_crypto_manager_settings_, verify_peer()) .WillByDefault(Return(false)); } + void SetClientInitialValues(security_manager::Protocol protocol, const std::string& client_ciphers_list) { + ON_CALL(*mock_client_manager_settings_, force_unprotected_service()) + .WillByDefault(ReturnRef(forced_unprotected_service_)); + ON_CALL(*mock_client_manager_settings_, force_protected_service()) + .WillByDefault(ReturnRef(forced_protected_service_)); ON_CALL(*mock_client_manager_settings_, security_manager_mode()) .WillByDefault(Return(security_manager::CLIENT)); ON_CALL(*mock_client_manager_settings_, security_manager_protocol_name()) @@ -306,11 +326,13 @@ class SSLTestParam : public testing::TestWithParam { mock_crypto_manager_settings_; utils::SharedPtr > mock_client_manager_settings_; - security_manager::CryptoManager* crypto_manager = NULL; - security_manager::CryptoManager* client_manager = NULL; - security_manager::SSLContext* server_ctx = NULL; - security_manager::SSLContext* client_ctx = NULL; + security_manager::CryptoManager* crypto_manager_; + security_manager::CryptoManager* client_manager_; + security_manager::SSLContext* server_ctx_; + security_manager::SSLContext* client_ctx_; std::string certificate_data_base64_; + const std::vector forced_unprotected_service_; + const std::vector forced_protected_service_; }; class SSLTestForTLS1_2 : public SSLTestParam {}; @@ -332,8 +354,13 @@ INSTANTIATE_TEST_CASE_P( ProtocolAndCipher(security_manager::SSLv3, security_manager::SSLv3, kFordCipher, - kFordCipher) + kFordCipher) #endif + , + ProtocolAndCipher(security_manager::DTLSv1, + security_manager::DTLSv1, + kFordCipher, + kFordCipher))); )); INSTANTIATE_TEST_CASE_P( @@ -382,7 +409,7 @@ INSTANTIATE_TEST_CASE_P( TEST_F(SSLTest, OnTSL2Protocol_BrokenHandshake) { ASSERT_EQ(security_manager::SSLContext::Handshake_Result_Success, - client_ctx->StartHandshake(&kClientBuf, &client_buf_len)); + client_ctx_->StartHandshake(&kClientBuf, &client_buf_len)); ASSERT_FALSE(NULL == kClientBuf); ASSERT_LT(0u, client_buf_len); // Broke 3 bytes for get abnormal fail of handshake @@ -390,26 +417,26 @@ TEST_F(SSLTest, OnTSL2Protocol_BrokenHandshake) { const_cast(kClientBuf)[client_buf_len / 2] ^= 0xFF; const_cast(kClientBuf)[client_buf_len - 1] ^= 0xFF; ASSERT_EQ(security_manager::SSLContext::Handshake_Result_AbnormalFail, - server_ctx->DoHandshakeStep( + server_ctx_->DoHandshakeStep( kClientBuf, client_buf_len, &kServerBuf, &server_buf_len)); - EXPECT_EQ("Initialization is not completed", server_ctx->LastError()); - EXPECT_EQ("Initialization is not completed", client_ctx->LastError()); + EXPECT_EQ("Initialization is not completed", server_ctx_->LastError()); + EXPECT_EQ("Initialization is not completed", client_ctx_->LastError()); } // TODO {AKozoriz} : Unexpected uncomplited init of SSL component. // In this and next tests. // Must be fixed after merge to develop. TEST_F(SSLTest, OnTSL2Protocol_Positive) { - ASSERT_EQ(client_ctx->StartHandshake(&kClientBuf, &client_buf_len), + ASSERT_EQ(client_ctx_->StartHandshake(&kClientBuf, &client_buf_len), security_manager::SSLContext::Handshake_Result_Success); - EXPECT_FALSE(server_ctx->IsInitCompleted()); + EXPECT_FALSE(server_ctx_->IsInitCompleted()); while (true) { ASSERT_TRUE(NULL != kClientBuf); ASSERT_LT(0u, client_buf_len); const security_manager::SSLContext::HandshakeResult server_result = - server_ctx->DoHandshakeStep( + server_ctx_->DoHandshakeStep( kClientBuf, client_buf_len, &kServerBuf, &server_buf_len); ASSERT_EQ(security_manager::SSLContext::Handshake_Result_Success, server_result); @@ -417,11 +444,11 @@ TEST_F(SSLTest, OnTSL2Protocol_Positive) { ASSERT_LT(0u, server_buf_len); const security_manager::SSLContext::HandshakeResult client_result = - client_ctx->DoHandshakeStep( + client_ctx_->DoHandshakeStep( kServerBuf, server_buf_len, &kClientBuf, &client_buf_len); ASSERT_EQ(security_manager::SSLContext::Handshake_Result_Success, client_result); - if (server_ctx->IsInitCompleted()) { + if (server_ctx_->IsInitCompleted()) { break; } @@ -432,22 +459,22 @@ TEST_F(SSLTest, OnTSL2Protocol_Positive) { ASSERT_TRUE(NULL == kClientBuf); ASSERT_EQ(0u, client_buf_len); // expect both side initialization complete - EXPECT_TRUE(client_ctx->IsInitCompleted()); - EXPECT_TRUE(server_ctx->IsInitCompleted()); + EXPECT_TRUE(client_ctx_->IsInitCompleted()); + EXPECT_TRUE(server_ctx_->IsInitCompleted()); // Encrypt text on client side const uint8_t* text = reinterpret_cast("abra"); const uint8_t* encrypted_text = 0; size_t text_len = 4; size_t encrypted_text_len; - EXPECT_TRUE(client_ctx->Encrypt( + EXPECT_TRUE(client_ctx_->Encrypt( text, text_len, &encrypted_text, &encrypted_text_len)); ASSERT_NE(reinterpret_cast(NULL), encrypted_text); ASSERT_LT(0u, encrypted_text_len); // Decrypt text on server side - EXPECT_TRUE(server_ctx->Decrypt( + EXPECT_TRUE(server_ctx_->Decrypt( encrypted_text, encrypted_text_len, &text, &text_len)); ASSERT_NE(reinterpret_cast(NULL), text); ASSERT_LT(0u, text_len); @@ -457,34 +484,34 @@ TEST_F(SSLTest, OnTSL2Protocol_Positive) { TEST_F(SSLTest, OnTSL2Protocol_EcncryptionFail) { ASSERT_EQ(security_manager::SSLContext::Handshake_Result_Success, - client_ctx->StartHandshake(&kClientBuf, &client_buf_len)); + client_ctx_->StartHandshake(&kClientBuf, &client_buf_len)); - while (!server_ctx->IsInitCompleted()) { + while (!server_ctx_->IsInitCompleted()) { ASSERT_FALSE(NULL == kClientBuf); ASSERT_LT(0u, client_buf_len); ASSERT_EQ(security_manager::SSLContext::Handshake_Result_Success, - server_ctx->DoHandshakeStep( + server_ctx_->DoHandshakeStep( kClientBuf, client_buf_len, &kServerBuf, &server_buf_len)); ASSERT_FALSE(NULL == kServerBuf); ASSERT_LT(0u, server_buf_len); ASSERT_EQ(security_manager::SSLContext::Handshake_Result_Success, - client_ctx->DoHandshakeStep( + client_ctx_->DoHandshakeStep( kServerBuf, server_buf_len, &kClientBuf, &client_buf_len)); } // Expect empty buffers after init complete ASSERT_TRUE(NULL == kClientBuf); ASSERT_EQ(0u, client_buf_len); // Expect both side initialization complete - EXPECT_TRUE(client_ctx->IsInitCompleted()); - EXPECT_TRUE(server_ctx->IsInitCompleted()); + EXPECT_TRUE(client_ctx_->IsInitCompleted()); + EXPECT_TRUE(server_ctx_->IsInitCompleted()); // Encrypt text on client side const uint8_t* text = reinterpret_cast("abra"); const uint8_t* encrypted_text = 0; size_t text_len = 4; size_t encrypted_text_len; - EXPECT_TRUE(client_ctx->Encrypt( + EXPECT_TRUE(client_ctx_->Encrypt( text, text_len, &encrypted_text, &encrypted_text_len)); ASSERT_NE(reinterpret_cast(NULL), encrypted_text); ASSERT_LT(0u, encrypted_text_len); @@ -497,29 +524,30 @@ TEST_F(SSLTest, OnTSL2Protocol_EcncryptionFail) { const uint8_t* out_text; size_t out_text_size; // Decrypt broken text on server side - EXPECT_FALSE(server_ctx->Decrypt( + EXPECT_FALSE(server_ctx_->Decrypt( &broken[0], broken.size(), &out_text, &out_text_size)); // Check after broken message that server encryption and decryption fail // Encrypte message on server side - EXPECT_FALSE(server_ctx->Decrypt( + EXPECT_FALSE(server_ctx_->Decrypt( encrypted_text, encrypted_text_len, &out_text, &out_text_size)); - EXPECT_FALSE(server_ctx->Encrypt( + EXPECT_FALSE(server_ctx_->Encrypt( text, text_len, &encrypted_text, &encrypted_text_len)); } TEST_P(SSLTestParam, ClientAndServerNotTLSv1_2_HandshakeFailed) { ASSERT_EQ(security_manager::SSLContext::Handshake_Result_AbnormalFail, - client_ctx->StartHandshake(&kClientBuf, &client_buf_len)); + client_ctx_->StartHandshake(&kClientBuf, &client_buf_len)); + EXPECT_TRUE(NULL == kClientBuf); EXPECT_EQ(0u, client_buf_len); ASSERT_EQ(security_manager::SSLContext::Handshake_Result_Success, - server_ctx->DoHandshakeStep( + server_ctx_->DoHandshakeStep( kClientBuf, client_buf_len, &kServerBuf, &server_buf_len)); EXPECT_TRUE(NULL == kServerBuf); EXPECT_EQ(0u, server_buf_len); - EXPECT_FALSE(server_ctx->IsInitCompleted()); + EXPECT_FALSE(server_ctx_->IsInitCompleted()); } INSTANTIATE_TEST_CASE_P( @@ -544,16 +572,16 @@ INSTANTIATE_TEST_CASE_P( TEST_P(SSLTestForTLS1_2, HandshakeFailed) { ASSERT_EQ(security_manager::SSLContext::Handshake_Result_Success, - client_ctx->StartHandshake(&kClientBuf, &client_buf_len)); + client_ctx_->StartHandshake(&kClientBuf, &client_buf_len)); EXPECT_FALSE(NULL == kClientBuf); ASSERT_LT(0u, client_buf_len); ASSERT_EQ(security_manager::SSLContext::Handshake_Result_AbnormalFail, - server_ctx->DoHandshakeStep( + server_ctx_->DoHandshakeStep( kClientBuf, client_buf_len, &kServerBuf, &server_buf_len)); EXPECT_TRUE(NULL == kServerBuf); EXPECT_EQ(0u, server_buf_len); - EXPECT_FALSE(server_ctx->IsInitCompleted()); + EXPECT_FALSE(server_ctx_->IsInitCompleted()); } } // namespace ssl_context_test -- cgit v1.2.1