diff --git a/services/implementation/include/authentication_v2/dm_auth_manager_base.h b/services/implementation/include/authentication_v2/dm_auth_manager_base.h index 0e0e2096511b6906811ddf74362fba523e32e8a0..0d73ff77a101b4d78f058158be7897524f5e96d6 100644 --- a/services/implementation/include/authentication_v2/dm_auth_manager_base.h +++ b/services/implementation/include/authentication_v2/dm_auth_manager_base.h @@ -96,6 +96,7 @@ extern const int32_t HML_SESSION_TIMEOUT; extern const int32_t SESSION_HEARTBEAT_TIMEOUT; extern const int32_t PIN_AUTH_TIMEOUT; extern const int32_t EVENT_TIMEOUT; +extern const int32_t WAIT_TIMEOUT; extern const int32_t DM_AUTH_TYPE_MAX; extern const int32_t DM_AUTH_TYPE_MIN; diff --git a/services/implementation/include/authentication_v2/dm_auth_state_machine.h b/services/implementation/include/authentication_v2/dm_auth_state_machine.h index 02781031fbf30e1c296d147899f0fb739d4a8494..ed71148367aba8ad7be25927a1446e8eae1550ab 100644 --- a/services/implementation/include/authentication_v2/dm_auth_state_machine.h +++ b/services/implementation/include/authentication_v2/dm_auth_state_machine.h @@ -25,6 +25,7 @@ #include #include #include +#include #include "dm_auth_state.h" @@ -113,6 +114,7 @@ private: std::condition_variable stateCv_; std::mutex eventMutex_; std::condition_variable eventCv_; + bool eventCvReady_{false}; // Direction of authentication DmAuthDirection direction_; diff --git a/services/implementation/include/dependency/hichain/hichain_auth_connector.h b/services/implementation/include/dependency/hichain/hichain_auth_connector.h index 92ab841fa49c1f58009565764507bd68e7d1015e..3a3fe46c6d7506eeae64655d41222496cd6af0d3 100644 --- a/services/implementation/include/dependency/hichain/hichain_auth_connector.h +++ b/services/implementation/include/dependency/hichain/hichain_auth_connector.h @@ -60,7 +60,9 @@ public: int32_t ImportCredential(int32_t osAccountId, int32_t peerOsAccountId, std::string deviceId, std::string publicKey); int32_t DeleteCredential(const std::string &deviceId, int32_t userId, int32_t peerUserId); int32_t RegisterHiChainAuthCallback(std::shared_ptr callback); + int32_t UnRegisterHiChainAuthCallback(); int32_t RegisterHiChainAuthCallbackById(int64_t id, std::shared_ptr callback); + int32_t UnRegisterHiChainAuthCallbackById(int64_t id); int32_t GetCredential(std::string &localUdid, int32_t osAccountId, std::string &publicKey); int32_t ProcessCredData(int64_t authReqId, const std::string &data); diff --git a/services/implementation/include/device_manager_service_impl.h b/services/implementation/include/device_manager_service_impl.h index 37f9557c127255960df8c1951f8fc68e9dcd8423..65779f7b3ffe14b0f8a83d9a9023961f01ab496d 100644 --- a/services/implementation/include/device_manager_service_impl.h +++ b/services/implementation/include/device_manager_service_impl.h @@ -265,6 +265,7 @@ private: std::mutex mapMutex_; // sessionsMap_的锁 std::map sessionEnableCvMap_; // Condition variable corresponding to the session std::map sessionEnableMutexMap_; // Lock corresponding to the session + std::map sessionEnableCvReadyMap_; // Condition variable ready flag std::map logicalSessionId2TokenIdMap_; // The relationship between logicalSessionId and tokenId std::map logicalSessionId2SessionIdMap_; // The relationship logicalSessionId and physical sessionId std::map> configsMap_; // Import when authMgr is not initialized diff --git a/services/implementation/src/authentication_v2/auth_manager.cpp b/services/implementation/src/authentication_v2/auth_manager.cpp index 86722fb50845ddc9a60ea0351de88531463ce997..1ec1620477021fac4db06bc781fa600b6bf4dc26 100644 --- a/services/implementation/src/authentication_v2/auth_manager.cpp +++ b/services/implementation/src/authentication_v2/auth_manager.cpp @@ -149,8 +149,10 @@ AuthManager::~AuthManager() context_->successFinished = true; context_->authStateMachine->Stop(); // Stop statemMachine thread context_->timer->DeleteAll(); + LOGI("AuthManager context variables destroy successful."); } bindParam_.clear(); + LOGI("DmAuthManager destructor"); } void AuthManager::RegisterCleanNotifyCallback(CleanNotifyCallback cleanNotifyCallback) diff --git a/services/implementation/src/authentication_v2/dm_auth_manager_base.cpp b/services/implementation/src/authentication_v2/dm_auth_manager_base.cpp index 114326d9d88add61490987b4dc582d0d5dbe0af1..30fff0c47414d8f1dd6de96d83a7002e1fd61c8e 100644 --- a/services/implementation/src/authentication_v2/dm_auth_manager_base.cpp +++ b/services/implementation/src/authentication_v2/dm_auth_manager_base.cpp @@ -93,6 +93,7 @@ const int32_t HML_SESSION_TIMEOUT = 10; const int32_t SESSION_HEARTBEAT_TIMEOUT = 50; const int32_t PIN_AUTH_TIMEOUT = 60; const int32_t EVENT_TIMEOUT = 5000; // 5000 ms +const int32_t WAIT_TIMEOUT = 2000; // 2000 ms int32_t AuthManagerBase::AuthenticateDevice(const std::string &pkgName, int32_t authType, diff --git a/services/implementation/src/authentication_v2/dm_auth_state_machine.cpp b/services/implementation/src/authentication_v2/dm_auth_state_machine.cpp index fea4121847bb63a0245eee0c5ca6d1c5c0744134..8d3ea5d3207e3c452766c4d845dd9c2e65c14fc8 100644 --- a/services/implementation/src/authentication_v2/dm_auth_state_machine.cpp +++ b/services/implementation/src/authentication_v2/dm_auth_state_machine.cpp @@ -262,9 +262,18 @@ DmEventType DmAuthStateMachine::WaitExpectEvent(DmEventType eventType) std::unique_lock lock(eventMutex_); auto startTime = std::chrono::high_resolution_clock::now(); while (running_.load()) { - eventCv_.wait(lock, [&] { - return !running_.load() || !eventQueue_.empty(); - }); + if (eventCv_.wait_for(lock, std::chrono::seconds(WAIT_TIMEOUT), [&] { + return !running_.load() || !eventQueue_.empty() || eventCvReady_; + })) { + eventCvReady_ = false; + LOGI("DmAuthStateMachine: WaitExpectEvent wait successful."); + } else { + if (!eventCvReady_) { + LOGE("DmAuthStateMachine: WaitExpectEvent wait timeout."); + return DmEventType::ON_TIMEOUT; + } + eventCvReady_ = false; + } if (!running_.load()) { return DmEventType::ON_FAIL; } @@ -296,6 +305,7 @@ void DmAuthStateMachine::NotifyEventFinish(DmEventType eventType) { std::unique_lock lock(eventMutex_); eventQueue_.push(eventType); + eventCvReady_ = true; } eventCv_.notify_one(); if (eventType == DmEventType::ON_FAIL) { diff --git a/services/implementation/src/dependency/hichain/hichain_auth_connector.cpp b/services/implementation/src/dependency/hichain/hichain_auth_connector.cpp index d456a7da91c6a4f676f528cea9b1fbd12046cf48..2766f95a0a95dceb436b82855a9d3c22f5fe4148 100644 --- a/services/implementation/src/dependency/hichain/hichain_auth_connector.cpp +++ b/services/implementation/src/dependency/hichain/hichain_auth_connector.cpp @@ -65,6 +65,13 @@ int32_t HiChainAuthConnector::RegisterHiChainAuthCallback(std::shared_ptr lock(dmDeviceAuthCallbackMutex_); + dmDeviceAuthCallback_ = nullptr; + return DM_OK; +} + // 当前id为tokenId对应生成的requestId int32_t HiChainAuthConnector::RegisterHiChainAuthCallbackById(int64_t id, std::shared_ptr callback) @@ -74,6 +81,13 @@ int32_t HiChainAuthConnector::RegisterHiChainAuthCallbackById(int64_t id, return DM_OK; } +int32_t HiChainAuthConnector::UnRegisterHiChainAuthCallbackById(int64_t id) +{ + std::lock_guard lock(dmDeviceAuthCallbackMutex_); + dmDeviceAuthCallbackMap_[id] = nullptr; + return DM_OK; +} + std::shared_ptr HiChainAuthConnector::GetDeviceAuthCallback(int64_t id) { if (dmDeviceAuthCallbackMap_.find(id) != dmDeviceAuthCallbackMap_.end()) { diff --git a/services/implementation/src/dependency/softbus/softbus_session.cpp b/services/implementation/src/dependency/softbus/softbus_session.cpp index c4aea1706aa9a7cf7c5fb3a2bec3773f500b54d2..056eb40442acffaca75ff0bc67d5ff22945fa10f 100644 --- a/services/implementation/src/dependency/softbus/softbus_session.cpp +++ b/services/implementation/src/dependency/softbus/softbus_session.cpp @@ -142,9 +142,9 @@ int32_t SoftbusSession::SendHeartbeatData(int32_t sessionId, std::string &messag int SoftbusSession::OnSessionOpened(int sessionId, int result) { - LOGD("OnSessionOpened, success, sessionId: %{public}d.", sessionId); + LOGI("OnSessionOpened, success, sessionId: %{public}d, result: %{public}d.", sessionId, result); if (sessionCallback_ == nullptr) { - LOGD("Session callback is not registered."); + LOGI("Session callback is not registered."); return DM_OK; } int32_t sessionSide = GetSessionSide(sessionId); diff --git a/services/implementation/src/device_manager_service_impl.cpp b/services/implementation/src/device_manager_service_impl.cpp index 395e37b25b243c02910c3971f09fda02a91f42ee..d2852c23566f669b1d11980632452a970d08795d 100644 --- a/services/implementation/src/device_manager_service_impl.cpp +++ b/services/implementation/src/device_manager_service_impl.cpp @@ -345,7 +345,7 @@ void DeviceManagerServiceImpl::CleanAuthMgrByLogicalSessionId(uint64_t logicalSe authMgr_->SetTransferReady(true); authMgr_->ClearSoftbusSessionCallback(); } - + hiChainAuthConnector_->UnRegisterHiChainAuthCallbackById(logicalSessionId); if (authMgrMap_.find(tokenId) != authMgrMap_.end()) { authMgrMap_[tokenId] = nullptr; authMgrMap_.erase(tokenId); @@ -455,6 +455,7 @@ void DeviceManagerServiceImpl::Release() softbusConnector_->UnRegisterSoftbusStateCallback(); softbusConnector_->GetSoftbusSession()->UnRegisterSessionCallback(); hiChainConnector_->UnRegisterHiChainCallback(); + hiChainAuthConnector_->UnRegisterHiChainAuthCallback(); authMgr_ = nullptr; for (auto& pair : authMgrMap_) { pair.second = nullptr; @@ -711,6 +712,12 @@ int DeviceManagerServiceImpl::OnSessionOpened(int sessionId, int result) { { std::lock_guard lock(sessionEnableMutexMap_[sessionId]); + if (result == 0) { + sessionEnableCvReadyMap_[sessionId] = true; + LOGE("OnSessionOpened successful, sessionId: %{public}d", sessionId); + } else { + LOGE("OnSessionOpened failed, sessionId: %{public}d, res: %{public}d", sessionId, result); + } sessionEnableCvMap_[sessionId].notify_all(); } std::string peerUdid = ""; @@ -777,38 +784,34 @@ std::shared_ptr DeviceManagerServiceImpl::GetAuthMgrByMessage(i { uint64_t tokenId = 0; if (msgType == MSG_TYPE_REQ_ACL_NEGOTIATE) { - if (logicalSessionId != 0) { - curSession->logicalSessionSet_.insert(logicalSessionId); - std::string bundleName; - int32_t displayId = 0; - if (jsonObject[TAG_PEER_BUNDLE_NAME_V2].IsString()) { - bundleName = jsonObject[TAG_PEER_BUNDLE_NAME_V2].Get(); - } - if (jsonObject[DM_TAG_PEER_DISPLAY_ID].IsNumberInteger()) { - displayId = jsonObject[DM_TAG_PEER_DISPLAY_ID].Get(); - } - tokenId = GetTokenId(false, displayId, bundleName); - if (tokenId == 0) { - LOGE("GetAuthMgrByMessage, Get tokenId failed."); - return nullptr; - } - if (logicalSessionId2TokenIdMap_.find(logicalSessionId) != logicalSessionId2TokenIdMap_.end()) { - LOGE("GetAuthMgrByMessage, logicalSessionId exists in logicalSessionId2TokenIdMap_."); - return nullptr; - } - logicalSessionId2TokenIdMap_[logicalSessionId] = tokenId; + std::string bundleName; + int32_t displayId = 0; + if (jsonObject[TAG_PEER_BUNDLE_NAME_V2].IsString()) { + bundleName = jsonObject[TAG_PEER_BUNDLE_NAME_V2].Get(); + } + if (jsonObject[DM_TAG_PEER_DISPLAY_ID].IsNumberInteger()) { + displayId = jsonObject[DM_TAG_PEER_DISPLAY_ID].Get(); + } + tokenId = GetTokenId(false, displayId, bundleName); + if (tokenId == 0) { + LOGE("GetAuthMgrByMessage, Get tokenId failed."); + return nullptr; } if (InitAndRegisterAuthMgr(false, tokenId, curSession, logicalSessionId) != DM_OK) { return nullptr; } + curSession->logicalSessionSet_.insert(logicalSessionId); + if (logicalSessionId2TokenIdMap_.find(logicalSessionId) != logicalSessionId2TokenIdMap_.end()) { + LOGE("GetAuthMgrByMessage, logicalSessionId exists in logicalSessionId2TokenIdMap_."); + return nullptr; + } + logicalSessionId2TokenIdMap_[logicalSessionId] = tokenId; } else { - if (logicalSessionId != 0) { - if (curSession->logicalSessionSet_.find(logicalSessionId) == curSession->logicalSessionSet_.end()) { - LOGE("GetAuthMgrByMessage, The logical session ID does not exist in the physical session."); - return nullptr; - } - tokenId = logicalSessionId2TokenIdMap_[logicalSessionId]; + if (curSession->logicalSessionSet_.find(logicalSessionId) == curSession->logicalSessionSet_.end()) { + LOGE("GetAuthMgrByMessage, The logical session ID does not exist in the physical session."); + return nullptr; } + tokenId = logicalSessionId2TokenIdMap_[logicalSessionId]; } return GetAuthMgrByTokenId(tokenId); @@ -876,6 +879,7 @@ int32_t DeviceManagerServiceImpl::TransferByAuthType(int32_t authType, authMgr_->EnableInsensibleSwitching(); curSession->logicalSessionSet_.insert(0); curSession->logicalSessionCnt_.fetch_add(1); + logicalSessionId2SessionIdMap_[0] = sessionId; authMgr->OnSessionDisable(); } else { authMgr_->DisableInsensibleSwitching(); @@ -1000,9 +1004,13 @@ void DeviceManagerServiceImpl::OnBytesReceived(int sessionId, const void *data,         2. Old-to-new: When the sink side receives an 80 message and detects a version mismatch, it receives the 80 message, directly creates a new old protocol authMgr, and re-OnSessionOpened and OnBytesReceived.         */ - if (TransferOldAuthMgr(msgType, jsonObject, curSession) != DM_OK) { - LOGE("DeviceManagerServiceImpl::OnBytesReceived TransferOldAuthMgr failed"); - return; + if (curSession->version_ == "" || CompareVersion(curSession->version_, DM_VERSION_5_0_OLD_MAX)) { + if (TransferOldAuthMgr(msgType, jsonObject, curSession) != DM_OK) { + LOGE("DeviceManagerServiceImpl::OnBytesReceived TransferOldAuthMgr failed"); + return; + } + } else { + LOGI("DeviceManagerServiceImpl::OnBytesReceived Reuse Old AuthMgr, sessionId: %{public}d.", sessionId); } authMgr = authMgr_; } @@ -1274,7 +1282,7 @@ int32_t DeviceManagerServiceImpl::ImportAuthCode(const std::string &pkgName, con } LOGI("DeviceManagerServiceImpl::ImportAuthCode pkgName is %{public}s, authCode is %{public}s", - pkgName.c_str(), authCode.c_str()); + pkgName.c_str(), GetAnonyString(authCode).c_str()); auto authMgr = GetAuthMgr(); if (authMgr == nullptr) { auto config = GetConfigByTokenId(); @@ -1398,20 +1406,24 @@ std::shared_ptr DeviceManagerServiceImpl::GetOrCreateSession(const std: sessionId = OpenAuthSession(deviceId, bindParam); if (sessionId < 0) { - goto error; + LOGE("OpenAuthSession failed, stop the authentication"); + return nullptr; } std::unique_lock cvLock(sessionEnableMutexMap_[sessionId]); - sessionEnableCvMap_[sessionId].wait(cvLock); - + sessionEnableCvReadyMap_[sessionId] = false; + if (sessionEnableCvMap_[sessionId].wait_for(cvLock, std::chrono::seconds(WAIT_TIMEOUT), + [&] { return sessionEnableCvReadyMap_[sessionId]; })) { + LOGI("session enable, sessionId: %{public}d.", sessionId); + } else { + LOGE("wait session enable timeout or enable fail, sessionId: %{public}d.", sessionId); + return nullptr; + } instance = std::make_shared(sessionId, deviceId); deviceId2SessionIdMap_[deviceId] = sessionId; sessionsMap_[sessionId] = instance; } return instance; -error: - LOGE("OpenAuthSession failed, stop the authentication"); - return nullptr; } int32_t DeviceManagerServiceImpl::GetDeviceInfo(const PeerTargetId &targetId, std::string &addrType, @@ -1535,10 +1547,13 @@ int32_t DeviceManagerServiceImpl::BindTarget(const std::string &pkgName, const P // Logical session random number int sessionId = curSession->sessionId_; - uint64_t logicalSessionId = GenerateRandNum(sessionId); - if (curSession->logicalSessionSet_.find(logicalSessionId) != curSession->logicalSessionSet_.end()) { - LOGE("Failed to create the logical session."); - return ERR_DM_LOGIC_SESSION_CREATE_FAILED; + uint64_t logicalSessionId = 0; + if (curSession->version_ == "" || CompareVersion(curSession->version_, DM_VERSION_5_0_OLD_MAX)) { + logicalSessionId = GenerateRandNum(sessionId); + if (curSession->logicalSessionSet_.find(logicalSessionId) != curSession->logicalSessionSet_.end()) { + LOGE("Failed to create the logical session."); + return ERR_DM_LOGIC_SESSION_CREATE_FAILED; + } } // Create on the src end. @@ -1555,7 +1570,6 @@ int32_t DeviceManagerServiceImpl::BindTarget(const std::string &pkgName, const P auto authMgr = GetAuthMgrByTokenId(tokenId); if (authMgr == nullptr) { - LOGE("authMgr is nullptr"); return ERR_DM_POINT_NULL; } authMgr->SetBindTargetParams(targetId); diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 2ec361727581300d33f4d1f6beba8d904291bc42..b76926459d13c492253ff07e27f152e032c94774 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -2167,6 +2167,7 @@ ohos_unittest("UTTest_auth_confirm") { sources = [ "${devicemanager_path}/test/unittest/UTTest_auth_confirm.cpp", "${devicemanager_path}/test/unittest/mock/deviceprofile_connector_mock.cpp", + "${devicemanager_path}/test/unittest/mock/hichain_auth_connector_mock.cpp", ] deps = [ ":device_manager_test_common" ] diff --git a/test/unittest/UTTest_auth_confirm.cpp b/test/unittest/UTTest_auth_confirm.cpp index 5c0ceaa1d7b5a2a624459e1692d8cdf217447c77..676d439a33cf5d99d0593f40f15b59ee15daf2ce 100644 --- a/test/unittest/UTTest_auth_confirm.cpp +++ b/test/unittest/UTTest_auth_confirm.cpp @@ -23,23 +23,70 @@ namespace DistributedHardware { using namespace testing; +namespace { constexpr const char *TEST_DEVICE_ID = "deviceId"; constexpr const int32_t TEST_USER_ID = 0; constexpr const int64_t TEST_TOKEN_ID = 0; constexpr const char *TEST_CREDENTIAL_ID = "credentialId"; +constexpr const char *TEST_IDENTIAL_CRED_ID = "identialCredId"; +constexpr const char *TEST_SHARE_CRED_ID = "shareCredId"; +constexpr const char *TEST_POINT_TO_POINT_CRED_ID = "p2pCredId"; +constexpr const char *TEST_LNN_CRED_ID = "lnnCredId"; + +DistributedDeviceProfile::AccessControlProfile TestCreateAcl(const std::string credIdStr, int32_t bindType) +{ + DistributedDeviceProfile::Accesser accesser; + accesser.SetAccesserDeviceId(TEST_DEVICE_ID); + accesser.SetAccesserUserId(TEST_USER_ID); + accesser.SetAccesserTokenId(TEST_TOKEN_ID); + accesser.SetAccesserCredentialIdStr(credIdStr); + + DistributedDeviceProfile::Accessee accesee; + accesee.SetAccesseeDeviceId(TEST_DEVICE_ID); + accesee.SetAccesseeUserId(TEST_USER_ID); + accesee.SetAccesseeTokenId(TEST_TOKEN_ID); + accesee.SetAccesseeCredentialIdStr(credIdStr); + + DistributedDeviceProfile::AccessControlProfile profile; + profile.SetAccesser(accesser); + profile.SetAccessee(accesee); + profile.SetTrustDeviceId(TEST_DEVICE_ID); + profile.SetBindType(bindType); + return profile; +} + +void TestSetContext(std::shared_ptr context) +{ + context->accesser.deviceId = TEST_DEVICE_ID; + context->accesser.userId = TEST_USER_ID; + context->accesser.tokenId = TEST_TOKEN_ID; + context->accesser.deviceIdHash = Crypto::Sha256(context->accesser.deviceId); + context->accesser.tokenIdHash = Crypto::Sha256(std::to_string(context->accesser.tokenId)); + context->accessee.deviceId = TEST_DEVICE_ID; + context->accessee.userId = TEST_USER_ID; + context->accessee.tokenId = TEST_TOKEN_ID; + context->accessee.deviceIdHash = Crypto::Sha256(context->accessee.deviceId); + context->accessee.tokenIdHash = Crypto::Sha256(std::to_string(context->accessee.tokenId)); +} +} std::shared_ptr AuthConfirmTest::deviceProfileConnectorMock = nullptr; +std::shared_ptr AuthConfirmTest::dmHiChainAuthConnectorMock = nullptr; void AuthConfirmTest::SetUpTestCase() { deviceProfileConnectorMock = std::make_shared(); DmDeviceProfileConnector::dmDeviceProfileConnector = deviceProfileConnectorMock; + dmHiChainAuthConnectorMock = std::make_shared(); + DmHiChainAuthConnector::dmHiChainAuthConnector = dmHiChainAuthConnectorMock; } void AuthConfirmTest::TearDownTestCase() { deviceProfileConnectorMock = nullptr; DmDeviceProfileConnector::dmDeviceProfileConnector = nullptr; + dmHiChainAuthConnectorMock = nullptr; + DmHiChainAuthConnector::dmHiChainAuthConnector = nullptr; } void AuthConfirmTest::SetUp() @@ -61,6 +108,7 @@ void AuthConfirmTest::TearDown() authManager = nullptr; context = nullptr; Mock::VerifyAndClearExpectations(deviceProfileConnectorMock.get()); + Mock::VerifyAndClearExpectations(dmHiChainAuthConnectorMock.get()); } bool DmAuthState::IsScreenLocked() @@ -68,7 +116,6 @@ bool DmAuthState::IsScreenLocked() return false; } -// AuthSrcConfirmState HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetStateType_001, testing::ext::TestSize.Level1) { authManager = std::make_shared(softbusConnector, hiChainConnector, listener, @@ -114,21 +161,16 @@ HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_NegotiateCredential_001, testing:: authManager = std::make_shared(softbusConnector, hiChainConnector, listener, hiChainAuthConnector); std::shared_ptr authState = std::make_shared(); - std::string jsonStr = R"( - { - "identicalCredType": true, - "shareCredType": true, - "pointTopointCredType": true, - "lnnCredType": true - } - )"; + std::string jsonStr = R"({"identicalCredType":1,"shareCredType":2,"pointTopointCredType":256,"lnnCredType":3})"; context = authManager->GetAuthContext(); context->accessee.credTypeList = jsonStr; context->accesser.credTypeList = jsonStr; JsonObject jsonObject; - authState->NegotiateCredential(context, jsonObject); - EXPECT_TRUE(context != nullptr); + EXPECT_TRUE(jsonObject["identicalCredType"].Get() == 1); + EXPECT_TRUE(jsonObject["shareCredType"].Get() == 2); + EXPECT_TRUE(jsonObject["pointTopointCredType"].Get() == 256); + EXPECT_TRUE(jsonObject["lnnCredType"].Get() == 3); } HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_NegotiateAcl_001, testing::ext::TestSize.Level1) @@ -136,62 +178,40 @@ HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_NegotiateAcl_001, testing::ext::Te authManager = std::make_shared(softbusConnector, hiChainConnector, listener, hiChainAuthConnector); std::shared_ptr authState = std::make_shared(); - std::string jsonStr = R"( - { - "identicalAcl": true, - "shareAcl": true, - "pointTopointAcl": true, - "lnnAcl": true - } - )"; + std::string jsonStr = R"({"identicalAcl":1,"shareAcl":2,"pointTopointAcl":256,"lnnAcl":3})"; context = authManager->GetAuthContext(); context->accessee.aclTypeList = jsonStr; context->accesser.aclTypeList = jsonStr; JsonObject jsonObject; - - authState->NegotiateCredential(context, jsonObject); - EXPECT_TRUE(context != nullptr); + authState->NegotiateAcl(context, jsonObject); + EXPECT_TRUE(jsonObject["identicalAcl"].Get() == 1); + EXPECT_TRUE(jsonObject["shareAcl"].Get() == 2); + EXPECT_TRUE(jsonObject["pointTopointAcl"].Get() == 256); + EXPECT_TRUE(jsonObject["lnnAcl"].Get() == 3); } -// get identical credential HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetSrcCredentialInfo_001, testing::ext::TestSize.Level1) { authManager = std::make_shared(softbusConnector, hiChainConnector, listener, hiChainAuthConnector); std::shared_ptr authState = std::make_shared(); context = authManager->GetAuthContext(); - context->accesser.accountIdHash = context->accessee.accountIdHash = ""; JsonObject jsonObject; + + context->accesser.accountIdHash = context->accessee.accountIdHash = ""; + EXPECT_CALL(*dmHiChainAuthConnectorMock, QueryCredentialInfo(_, _, _)).WillOnce(Return(DM_OK)); authState->GetSrcCredentialInfo(context, jsonObject); - EXPECT_TRUE(context != nullptr); -} -// get share credential -HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetSrcCredentialInfo_002, testing::ext::TestSize.Level1) -{ - authManager = std::make_shared(softbusConnector, hiChainConnector, listener, - hiChainAuthConnector); - std::shared_ptr authState = std::make_shared(); - context = authManager->GetAuthContext(); context->accesser.accountIdHash = "0"; context->accessee.accountIdHash = "1"; - JsonObject jsonObject; + EXPECT_CALL(*dmHiChainAuthConnectorMock, QueryCredentialInfo(_, _, _)) + .WillOnce(Return(DM_OK)) + .WillOnce(Return(DM_OK)); authState->GetSrcCredentialInfo(context, jsonObject); - EXPECT_TRUE(context != nullptr); -} -// get point_to_point credential -HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetSrcCredentialInfo_003, testing::ext::TestSize.Level1) -{ - authManager = std::make_shared(softbusConnector, hiChainConnector, listener, - hiChainAuthConnector); - std::shared_ptr authState = std::make_shared(); - context = authManager->GetAuthContext(); context->accesser.accountIdHash = Crypto::Sha256("ohosAnonymousUid"); - context->accessee.accountIdHash = Crypto::Sha256("ohosAnonymousUid"); - JsonObject jsonObject; + EXPECT_CALL(*dmHiChainAuthConnectorMock, QueryCredentialInfo(_, _, _)).WillOnce(Return(DM_OK)); authState->GetSrcCredentialInfo(context, jsonObject); - EXPECT_TRUE(context != nullptr); } HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetSrcAclInfo_001, testing::ext::TestSize.Level1) @@ -201,72 +221,25 @@ HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetSrcAclInfo_001, testing::ext::T std::shared_ptr authState = std::make_shared(); context = authManager->GetAuthContext(); - context->accesser.deviceId = TEST_DEVICE_ID; - context->accessee.deviceId = TEST_DEVICE_ID; - context->accesser.deviceIdHash = Crypto::Sha256(context->accesser.deviceId); - context->accessee.deviceIdHash = Crypto::Sha256(context->accessee.deviceId); + TestSetContext(context); std::vector allProfiles; - DistributedDeviceProfile::AccessControlProfile profile; - profile.SetTrustDeviceId(context->accesser.deviceId); - profile.SetBindType(0); + DistributedDeviceProfile::AccessControlProfile profile = TestCreateAcl(TEST_IDENTIAL_CRED_ID, DM_IDENTICAL_ACCOUNT); allProfiles.push_back(profile); - profile.SetBindType(DM_IDENTICAL_ACCOUNT); - allProfiles.push_back(profile); - profile.SetBindType(DM_SHARE); - allProfiles.push_back(profile); - profile.SetBindType(DM_POINT_TO_POINT); + profile = TestCreateAcl(TEST_SHARE_CRED_ID, DM_SHARE); allProfiles.push_back(profile); + std::string jsonStr = R"({ + "identialCredId": {"credType": 1}, + "shareCredId": {"credType": 2} + })"; + JsonObject credInfo(jsonStr); + std::string jsonAclStr = R"({"identicalAcl":1,"shareAcl":2})"; + EXPECT_CALL(*deviceProfileConnectorMock, GetAllAclIncludeLnnAcl()).WillOnce(Return(allProfiles)); - JsonObject credInfo; JsonObject aclInf; authState->GetSrcAclInfo(context, credInfo, aclInf); -} - -HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetSrcAclInfoForP2P_001, testing::ext::TestSize.Level1) -{ - authManager = std::make_shared(softbusConnector, hiChainConnector, listener, - hiChainAuthConnector); - std::shared_ptr authState = std::make_shared(); - context = authManager->GetAuthContext(); - context->accesser.deviceId = TEST_DEVICE_ID; - context->accesser.userId = TEST_USER_ID; - context->accesser.tokenId = TEST_TOKEN_ID; - context->accessee.deviceId = TEST_DEVICE_ID; - context->accessee.userId = TEST_USER_ID; - context->accessee.tokenId = TEST_TOKEN_ID; - context->accessee.deviceIdHash = Crypto::Sha256(context->accessee.deviceId); - context->accessee.tokenIdHash = Crypto::Sha256(std::to_string(context->accessee.tokenId)); - - DistributedDeviceProfile::AccessControlProfile profile; - DistributedDeviceProfile::Accesser accesser; - accesser.SetAccesserDeviceId(TEST_DEVICE_ID); - accesser.SetAccesserUserId(TEST_USER_ID); - accesser.SetAccesserTokenId(TEST_TOKEN_ID); - accesser.SetAccesserCredentialIdStr(TEST_CREDENTIAL_ID); - profile.SetAccesser(accesser); - - DistributedDeviceProfile::Accessee accesee; - accesee.SetAccesseeDeviceId(TEST_DEVICE_ID); - accesee.SetAccesseeUserId(TEST_USER_ID); - accesee.SetAccesseeTokenId(TEST_TOKEN_ID); - accesee.SetAccesseeCredentialIdStr(TEST_CREDENTIAL_ID); - profile.SetAccessee(accesee); - - std::string jsonStr = R"( - { - "credentialId": { - "credType": 256, - "authorizedAppList": [0, 0] - } - } - )"; - JsonObject credInfo(jsonStr); - JsonObject aclInf; - - authState->GetSrcAclInfoForP2P(context, profile, credInfo, aclInf); - EXPECT_TRUE(context != nullptr); + EXPECT_TRUE(aclInf.Dump() == jsonAclStr); } HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_IdenticalAccountAclCompare_001, testing::ext::TestSize.Level1) @@ -275,10 +248,7 @@ HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_IdenticalAccountAclCompare_001, te hiChainAuthConnector); std::shared_ptr authState = std::make_shared(); context = authManager->GetAuthContext(); - context->accesser.deviceId = TEST_DEVICE_ID; - context->accesser.userId = TEST_USER_ID; - context->accessee.deviceId = TEST_DEVICE_ID; - context->accessee.deviceIdHash = Crypto::Sha256(context->accessee.deviceId); + TestSetContext(context); DistributedDeviceProfile::Accesser accesser; accesser.SetAccesserDeviceId(TEST_DEVICE_ID); @@ -294,11 +264,7 @@ HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_ShareAclCompare_001, testing::ext: hiChainAuthConnector); std::shared_ptr authState = std::make_shared(); context = authManager->GetAuthContext(); - - context->accesser.deviceId = TEST_DEVICE_ID; - context->accesser.userId = TEST_USER_ID; - context->accessee.deviceId = TEST_DEVICE_ID; - context->accessee.deviceIdHash = Crypto::Sha256(context->accessee.deviceId); + TestSetContext(context); DistributedDeviceProfile::Accesser accesser; accesser.SetAccesserDeviceId(TEST_DEVICE_ID); @@ -315,15 +281,7 @@ HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_Point2PointAclCompare_001, testing hiChainAuthConnector); std::shared_ptr authState = std::make_shared(); context = authManager->GetAuthContext(); - - context->accesser.deviceId = TEST_DEVICE_ID; - context->accesser.userId = TEST_USER_ID; - context->accesser.tokenId = TEST_TOKEN_ID; - - context->accessee.deviceId = TEST_DEVICE_ID; - context->accessee.tokenId = TEST_TOKEN_ID; - context->accessee.deviceIdHash = Crypto::Sha256(context->accessee.deviceId); - context->accessee.tokenIdHash = Crypto::Sha256(std::to_string(context->accessee.tokenId)); + TestSetContext(context); DistributedDeviceProfile::Accesser accesser; accesser.SetAccesserDeviceId(TEST_DEVICE_ID); @@ -344,15 +302,7 @@ HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_LnnAclCompare_001, testing::ext::T hiChainAuthConnector); std::shared_ptr authState = std::make_shared(); context = authManager->GetAuthContext(); - - context->accesser.deviceId = TEST_DEVICE_ID; - context->accesser.userId = TEST_USER_ID; - context->accesser.tokenId = TEST_TOKEN_ID; - - context->accessee.deviceId = TEST_DEVICE_ID; - context->accessee.tokenId = TEST_TOKEN_ID; - context->accessee.deviceIdHash = Crypto::Sha256(context->accessee.deviceId); - context->accessee.tokenIdHash = Crypto::Sha256(std::to_string(context->accessee.tokenId)); + TestSetContext(context); DistributedDeviceProfile::Accesser accesser; accesser.SetAccesserDeviceId(TEST_DEVICE_ID); @@ -374,34 +324,18 @@ HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_CheckCredIdInAcl_001, testing::ext std::shared_ptr authState = std::make_shared(); context = authManager->GetAuthContext(); - DistributedDeviceProfile::AccessControlProfile profile; - DistributedDeviceProfile::Accesser accesser; - accesser.SetAccesserDeviceId(TEST_DEVICE_ID); - accesser.SetAccesserUserId(TEST_USER_ID); - accesser.SetAccesserTokenId(TEST_TOKEN_ID); - accesser.SetAccesserCredentialIdStr(TEST_CREDENTIAL_ID); - profile.SetAccesser(accesser); - DistributedDeviceProfile::Accessee accessee; - accessee.SetAccesseeDeviceId(TEST_DEVICE_ID); - accessee.SetAccesseeUserId(TEST_USER_ID); - accessee.SetAccesseeTokenId(TEST_TOKEN_ID); - accessee.SetAccesseeCredentialIdStr(TEST_CREDENTIAL_ID); - profile.SetAccessee(accessee); - - std::string jsonStr = R"( - { - "credentialId": { - "credType": 3, - "authorizedAppList": [0, 0] - } + DistributedDeviceProfile::AccessControlProfile profile = TestCreateAcl(TEST_CREDENTIAL_ID, DM_LNN); + + std::string jsonStr = R"({ + "credentialId": { + "credType": 3, + "authorizedAppList": [0, 0] } - )"; + })"; JsonObject credInfo(jsonStr); - uint32_t bindType = 3; - - EXPECT_TRUE(authState->CheckCredIdInAcl(context, profile, credInfo, bindType)); + EXPECT_TRUE(authState->CheckCredIdInAcl(context, profile, credInfo, DM_LNN)); } HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetSrcCredType_001, testing::ext::TestSize.Level1) @@ -411,34 +345,21 @@ HWTEST_F(AuthConfirmTest, AuthSrcConfirmState_GetSrcCredType_001, testing::ext:: std::shared_ptr authState = std::make_shared(); context = authManager->GetAuthContext(); - std::string jsonStr = R"( - [ - { - "credType": 1, - "credId": "credId1" - }, - { - "credType": 2, - "credId": "credId2" - }, - { - "credType": "invalid", - "credId": "credId3" - }, - { - "credType": 4, - "credId": 12345 - } - ] - )"; - JsonObject credInfo(jsonStr); - JsonObject aclInfo; + std::string jsonCredStr = R"([ + {"credType": 1, "credId": "0"}, + {"credType": 2, "credId": "0"} + ])"; + JsonObject credInfo(jsonCredStr); + + std::string aclJsonStr = R"({"lnnAcl":3,"pointTopointAcl":256})"; + JsonObject aclInfo(aclJsonStr); + + std::string credTypeJsonStr = R"({"identicalCredType":1,"shareCredType":2})"; JsonObject credTypeJson; authState->GetSrcCredType(context, credInfo, aclInfo, credTypeJson); - EXPECT_TRUE(context != nullptr); + EXPECT_TRUE(credTypeJson.Dump() == credTypeJsonStr); } -// AuthSinkConfirmState HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_GetStateType_001, testing::ext::TestSize.Level1) { authManager = std::make_shared(softbusConnector, hiChainConnector, listener, @@ -502,8 +423,12 @@ HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_MatchFallBackCandidateList_001, t std::shared_ptr authState = std::make_shared(); context = authManager->GetAuthContext(); - authState->MatchFallBackCandidateList(context, AUTH_TYPE_PIN); - EXPECT_TRUE(context != nullptr); + authState->MatchFallBackCandidateList(context, DmAuthType::AUTH_TYPE_NFC); + EXPECT_TRUE(context->authTypeList.empty()); + + context->accessee.bundleName = "cast_engine_service"; + authState->MatchFallBackCandidateList(context, DmAuthType::AUTH_TYPE_NFC); + EXPECT_EQ(context->authTypeList[0], DmAuthType::AUTH_TYPE_PIN); } HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_ProcessBindAuthorize_001, testing::ext::TestSize.Level1) @@ -549,6 +474,5 @@ HWTEST_F(AuthConfirmTest, AuthSinkConfirmState_ProcessNoBindAuthorize_001, testi context->accessee.credTypeList = R"({"lnnCredType": true})"; EXPECT_EQ(authState->ProcessNoBindAuthorize(context), DM_OK); } - } // end namespace DistributedHardware } // end namespace OHOS \ No newline at end of file diff --git a/test/unittest/UTTest_auth_confirm.h b/test/unittest/UTTest_auth_confirm.h index ed2fb519a637c33c6f8b1e0e3b2065ace6413159..3009ba07912d6ff154806e301ff22930a70b5b20 100644 --- a/test/unittest/UTTest_auth_confirm.h +++ b/test/unittest/UTTest_auth_confirm.h @@ -20,6 +20,7 @@ #include "auth_manager.h" #include "deviceprofile_connector_mock.h" +#include "hichain_auth_connector_mock.h" namespace OHOS { namespace DistributedHardware { @@ -38,6 +39,7 @@ private: std::shared_ptr authManager; std::shared_ptr context; static std::shared_ptr deviceProfileConnectorMock; + static std::shared_ptr dmHiChainAuthConnectorMock; }; } // end namespace DistributedHardware diff --git a/test/unittest/mock/hichain_auth_connector_mock.cpp b/test/unittest/mock/hichain_auth_connector_mock.cpp index b1ee7600b43ebbd97f4d4b1f0bb03deaf0bd077a..71bbdf01afce69f991715d92f3e76f28a6d3e138 100644 --- a/test/unittest/mock/hichain_auth_connector_mock.cpp +++ b/test/unittest/mock/hichain_auth_connector_mock.cpp @@ -74,5 +74,9 @@ int32_t HiChainAuthConnector::AuthCredentialPinCode(int32_t osAccountId, int64_t return DmHiChainAuthConnector::dmHiChainAuthConnector->AuthCredentialPinCode(osAccountId, authReqId, pinCode); } +int32_t HiChainAuthConnector::QueryCredentialInfo(int32_t userId, const JsonObject &queryParams, JsonObject &resultJson) +{ + return DmHiChainAuthConnector::dmHiChainAuthConnector->QueryCredentialInfo(userId, queryParams, resultJson); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/hichain_auth_connector_mock.h b/test/unittest/mock/hichain_auth_connector_mock.h index 62ae5fa17eda4711a23c38a27c44c4b12e7324e5..d8f69f9e40afc21a211089a45b62af27359226eb 100644 --- a/test/unittest/mock/hichain_auth_connector_mock.h +++ b/test/unittest/mock/hichain_auth_connector_mock.h @@ -41,6 +41,7 @@ public: virtual int32_t AuthCredential(int32_t osAccountId, int64_t authReqId, const std::string &credId, const std::string &pinCode) = 0; virtual int32_t AuthCredentialPinCode(int32_t osAccountId, int64_t authReqId, const std::string &pinCode) = 0; + virtual int32_t QueryCredentialInfo(int32_t userId, const JsonObject &queryParams, JsonObject &resultJson) = 0; public: static inline std::shared_ptr dmHiChainAuthConnector = nullptr; }; @@ -58,6 +59,7 @@ public: MOCK_METHOD(int32_t, DeleteCredential, (int32_t, const std::string &)); MOCK_METHOD(int32_t, AuthCredential, (int32_t, int64_t, const std::string &, const std::string &)); MOCK_METHOD(int32_t, AuthCredentialPinCode, (int32_t, int64_t, const std::string &)); + MOCK_METHOD(int32_t, QueryCredentialInfo, (int32_t, const JsonObject &, JsonObject &)); }; } }