openharmony/useriam_user_auth_framework
1
0
Fork 0
mirror of https://gitee.com/openharmony/useriam_user_auth_framework synced 2025-02-13 12:44:13 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

!303 增加打点实现

Browse Source 
Merge pull request !303 from youliang_1314/master
This commit is contained in:
openharmony_ci 2022-07-02 06:42:41 +00:00 committed by Gitee
commit 76d58237c3
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
28 changed files with 518 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
dfx/inc/trace.h Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef TRACE_H
#define TRACE_H
#include "context_callback.h"
namespace OHOS {
namespace UserIam {
namespace UserAuth {
class Trace {
private:
static Trace trace;
static void ProcessCredChangeEvent(const ContextCallbackNotifyListener::MetaData &metaData);
static void ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData);
static void ProcessPinAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData);
static void ProcessDelUserEvent(const ContextCallbackNotifyListener::MetaData &metaData);
Trace();
~Trace();
};
} // namespace UserAuth
} // namespace UserIam
} // namespace OHOS
#endif // TRACE_H

80
dfx/src/trace.cpp Normal file
View File

@ -0,0 +1,80 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "trace.h"
#include "iam_logger.h"
#define LOG_LABEL UserIAM::Common::LABEL_USER_AUTH_SA
namespace OHOS {
namespace UserIam {
namespace UserAuth {
Trace Trace::trace;
Trace::Trace()
{
ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessCredChangeEvent);
ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessUserAuthEvent);
ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessPinAuthEvent);
ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessDelUserEvent);
}
Trace::~Trace()
{
}
void Trace::ProcessCredChangeEvent(const ContextCallbackNotifyListener::MetaData &metaData)
{
OperationType type = metaData.operationType;
bool checkRet = type == TRACE_ADD_CREDENTIAL || type == TRACE_DELETE_CREDENTIAL || type == TRACE_UPDATE_CREDENTIAL;
if (!checkRet) {
return;
}
IAM_LOGI("start to process cred change event");
}
void Trace::ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData)
{
bool checkRet = metaData.operationType == TRACE_AUTH_USER && metaData.authType.has_value() &&
metaData.authType != PIN;
if (!checkRet) {
return;
}
IAM_LOGI("start to process user auth event");
}
void Trace::ProcessPinAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData)
{
bool checkRet = metaData.operationType == TRACE_AUTH_USER && metaData.authType.has_value() &&
metaData.authType == PIN;
if (!checkRet) {
return;
}
IAM_LOGI("start to process pin auth event");
}
void Trace::ProcessDelUserEvent(const ContextCallbackNotifyListener::MetaData &metaData)
{
OperationType type = metaData.operationType;
bool checkRet = type == TRACE_DELETE_USER || type == TRACE_ENFORCE_DELETE_USER;
if (!checkRet) {
return;
}
IAM_LOGI("start to process del user event");
}
} // namespace UserAuth
} // namespace UserIam
} // namespace OHOS

2
services/BUILD.gn
View File

@ -30,11 +30,13 @@ ohos_shared_library("userauthservice") {
"common_defines/types",
"common_defines/interfaces",
"//base/useriam/user_auth_framework/common/utils",
"//base/useriam/user_auth_framework/dfx/inc",
]
remove_configs = [ "//build/config/compiler:no_exceptions" ]
sources = [
"//base/useriam/user_auth_framework/dfx/src/trace.cpp",
"base/src/finite_state_machine_builder.cpp",
"base/src/finite_state_machine_impl.cpp",
"base/src/hdi_wrapper.cpp",

2
services/common_defines/interfaces/user_idm.h
View File

@ -92,7 +92,7 @@ public:
* param callback get results / acquire info callback.
*/
virtual void AddCredential(std::optional<int32_t> userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback) = 0;
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback, bool isUpdate) = 0;
/*
* update user credential information.
*

3
services/context/inc/base_context.h
View File

@ -24,6 +24,7 @@
#include "nocopyable.h"
#include "context.h"
#include "context_callback.h"
namespace OHOS {
namespace UserIam {
@ -38,7 +39,6 @@ public:
uint64_t GetContextId() const override;
std::shared_ptr<ScheduleNode> GetScheduleNode(uint64_t scheduleId) const override;
void SetContextStopCallback(ContextStopCallback callback) override;
void OnScheduleStarted() override;
void OnScheduleProcessed(ExecutorRole src, int32_t moduleType, const std::vector<uint8_t> &acquireMsg) override;
@ -59,7 +59,6 @@ private:
std::string description_;
bool hasStarted_ = false;
std::mutex mutex_;
ContextStopCallback stopCallback_ = nullptr;
};
} // namespace UserAuth
} // namespace UserIam

9
services/context/inc/context.h
View File

@ -41,21 +41,12 @@ enum ContextType {
WIDGET_AUTH_CONTEXT,
};
class ContextCallback {
public:
virtual ~ContextCallback() = default;
virtual void onAcquireInfo(ExecutorRole src, int32_t moduleType, const std::vector<uint8_t> &acquireMsg) const = 0;
virtual void OnResult(int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) const = 0;
};
class Context {
public:
using ContextStopCallback = std::function<void()>;
virtual ~Context() = default;
virtual bool Start() = 0;
virtual bool Stop() = 0;
virtual void SetContextStopCallback(ContextStopCallback callback) = 0;
virtual uint64_t GetContextId() const = 0;
virtual ContextType GetContextType() const = 0;
virtual std::shared_ptr<ScheduleNode> GetScheduleNode(uint64_t scheduleId) const = 0;

87
services/context/inc/context_callback.h Normal file
View File

@ -0,0 +1,87 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef IAM_CONTEXT_CALLBACK_H
#define IAM_CONTEXT_CALLBACK_H
#include <cstdint>
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <singleton.h>
#include <vector>
#include "context.h"
#include "user_auth_callback.h"
#include "user_idm_callback.h"
namespace OHOS {
namespace UserIam {
namespace UserAuth {
enum OperationType : uint32_t {
TRACE_ADD_CREDENTIAL = 0,
TRACE_DELETE_CREDENTIAL = 1,
TRACE_DELETE_USER = 2,
TRACE_ENFORCE_DELETE_USER = 3,
TRACE_UPDATE_CREDENTIAL = 4,
TRACE_AUTH_USER = 5,
TRACE_IDENTIFY = 6,
};
class ContextCallbackNotifyListener : public Singleton<ContextCallbackNotifyListener> {
public:
struct MetaData {
OperationType operationType;
int32_t operationResult;
std::optional<int32_t> userId;
std::optional<int32_t> remainTime;
std::optional<int32_t> freezingTime;
std::optional<int32_t> sdkVersion;
std::optional<uint64_t> callingUid;
std::optional<AuthTrustLevel> atl;
std::optional<AuthType> authType;
std::chrono::time_point<std::chrono::steady_clock> startTime;
std::chrono::time_point<std::chrono::steady_clock> endTime;
};
using Notify = std::function<void(const MetaData &metaData)>;
void AddNotifier(const Notify &notify);
void Process(const MetaData &metaData);
private:
std::vector<Notify> notifierList_;
};
class ContextCallback {
public:
static std::shared_ptr<ContextCallback> NewInstance(sptr<IdmCallback> idmCallback, OperationType operationType);
static std::shared_ptr<ContextCallback> NewInstance(sptr<UserAuthCallback> userAuthCallback,
OperationType operationType);
virtual ~ContextCallback() = default;
virtual void onAcquireInfo(ExecutorRole src, int32_t moduleType, const std::vector<uint8_t> &acquireMsg) const = 0;
virtual void OnResult(int32_t resultCode, Attributes &finalResult) = 0;
virtual void SetTraceUserId(int32_t userId) = 0;
virtual void SetTraceRemainTime(int32_t remainTime) = 0;
virtual void SetTraceFreezingTime(int32_t freezingTime) = 0;
virtual void SetTraceSdkVersion(int32_t version) = 0;
virtual void SetTraceCallingUid(uint64_t callingUid) = 0;
virtual void SetTraceAuthType(AuthType authType) = 0;
virtual void SetTraceAuthTrustLevel(AuthTrustLevel atl) = 0;
virtual void SetCleaner(Context::ContextStopCallback callback) = 0;
};
} // namespace UserAuth
} // namespace UserIam
} // namespace OHOS
#endif // IAM_CONTEXT_CALLBACK_H

10
services/context/inc/context_factory.h
View File

@ -22,8 +22,7 @@
#include "singleton.h"
#include "context.h"
#include "user_auth_callback.h"
#include "user_idm_callback.h"
#include "context_callback.h"
namespace OHOS {
namespace UserIam {
@ -31,11 +30,12 @@ namespace UserAuth {
class ContextFactory : public DelayedSingleton<ContextFactory> {
public:
static std::shared_ptr<Context> CreateSimpleAuthContext(int32_t userId, const std::vector<uint8_t> &challenge,
AuthType authType, AuthTrustLevel authTrustLevel, uint64_t callingUid, sptr<UserAuthCallback> &callback);
AuthType authType, AuthTrustLevel authTrustLevel, uint64_t callingUid,
const std::shared_ptr<ContextCallback> &callback);
static std::shared_ptr<Context> CreateIdentifyContext(const std::vector<uint8_t> &challenge, AuthType authType,
uint64_t callingUid, sptr<UserAuthCallback> &callback);
uint64_t callingUid, const std::shared_ptr<ContextCallback> &callback);
static std::shared_ptr<Context> CreateEnrollContext(int32_t userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, uint64_t callingUid, const sptr<IdmCallback> &callback);
const std::vector<uint8_t> &token, uint64_t callingUid, const std::shared_ptr<ContextCallback> &callback);
static std::shared_ptr<Context> CreateWidgetAuthContext(std::shared_ptr<ContextCallback> callback);
};
} // namespace UserAuth

8
services/context/src/base_context.cpp
View File

@ -69,11 +69,6 @@ std::shared_ptr<ScheduleNode> BaseContext::GetScheduleNode(uint64_t scheduleId)
return nullptr;
}
void BaseContext::SetContextStopCallback(ContextStopCallback callback)
{
stopCallback_ = callback;
};
void BaseContext::OnScheduleStarted()
{
IAM_LOGI("%{public}s start", GetDescription());
@ -89,9 +84,6 @@ void BaseContext::OnScheduleProcessed(ExecutorRole src, int32_t moduleType, cons
void BaseContext::OnScheduleStoped(int32_t resultCode, const std::shared_ptr<Attributes> &finalResult)
{
OnResult(resultCode, finalResult);
if (stopCallback_ != nullptr) {
stopCallback_();
}
return;
}

118
services/context/src/context_callback_impl.cpp
View File

@ -16,23 +16,24 @@
#include "iam_check.h"
#include "iam_logger.h"
#include "iam_ptr.h"
#define LOG_LABEL UserIAM::Common::LABEL_USER_AUTH_SA
namespace OHOS {
namespace UserIam {
namespace UserAuth {
ContextCallbackImpl::ContextCallbackImpl(sptr<IdmCallback> idmCallback) : idmCallback_(idmCallback)
ContextCallbackImpl::ContextCallbackImpl(sptr<IdmCallback> idmCallback, OperationType operationType)
: idmCallback_(idmCallback)
{
if (idmCallback_ == nullptr) {
IAM_LOGE("idmCallback is nullptr, parameter is invalid");
}
metaData_.operationType = operationType;
metaData_.startTime = std::chrono::steady_clock::now();
}
ContextCallbackImpl::ContextCallbackImpl(sptr<UserAuthCallback> userAuthCallback) : userAuthCallback_(userAuthCallback)
ContextCallbackImpl::ContextCallbackImpl(sptr<UserAuthCallback> userAuthCallback, OperationType operationType)
: userAuthCallback_(userAuthCallback)
{
if (userAuthCallback_ == nullptr) {
IAM_LOGE("userAuthCallback is nullptr, parameter is invalid");
}
metaData_.operationType = operationType;
metaData_.startTime = std::chrono::steady_clock::now();
}
void ContextCallbackImpl::onAcquireInfo(ExecutorRole src, int32_t moduleType,
@ -57,21 +58,110 @@ void ContextCallbackImpl::onAcquireInfo(ExecutorRole src, int32_t moduleType,
}
}
void ContextCallbackImpl::OnResult(int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) const
void ContextCallbackImpl::OnResult(int32_t resultCode, Attributes &finalResult)
{
IF_FALSE_LOGE_AND_RETURN(finalResult != nullptr);
int32_t remainTime;
int32_t freezingTime;
metaData_.operationResult = resultCode;
if (finalResult.GetInt32Value(Attributes::ATTR_REMAIN_TIMES, remainTime)) {
metaData_.remainTime = remainTime;
}
if (finalResult.GetInt32Value(Attributes::ATTR_FREEZING_TIME, freezingTime)) {
metaData_.freezingTime = freezingTime;
}
metaData_.endTime = std::chrono::steady_clock::now();
if (idmCallback_ != nullptr) {
idmCallback_->OnResult(resultCode, *finalResult);
idmCallback_->OnResult(resultCode, finalResult);
}
if (userAuthCallback_ != nullptr) {
int32_t userId;
auto isIdentify = finalResult->GetInt32Value(Attributes::ATTR_USER_ID, userId);
auto isIdentify = finalResult.GetInt32Value(Attributes::ATTR_USER_ID, userId);
if (isIdentify) {
userAuthCallback_->OnIdentifyResult(resultCode, *finalResult);
userAuthCallback_->OnIdentifyResult(resultCode, finalResult);
} else {
userAuthCallback_->OnAuthResult(resultCode, *finalResult);
userAuthCallback_->OnAuthResult(resultCode, finalResult);
}
}
ContextCallbackNotifyListener::GetInstance().Process(metaData_);
if (stopCallback_ != nullptr) {
stopCallback_();
}
}
void ContextCallbackImpl::SetTraceUserId(int32_t userId)
{
metaData_.userId = userId;
}
void ContextCallbackImpl::SetTraceRemainTime(int32_t remainTime)
{
metaData_.remainTime = remainTime;
}
void ContextCallbackImpl::SetTraceFreezingTime(int32_t freezingTime)
{
metaData_.freezingTime = freezingTime;
}
void ContextCallbackImpl::SetTraceSdkVersion(int32_t version)
{
metaData_.sdkVersion = version;
}
void ContextCallbackImpl::SetTraceCallingUid(uint64_t callingUid)
{
metaData_.callingUid = callingUid;
}
void ContextCallbackImpl::SetTraceAuthType(AuthType authType)
{
metaData_.authType = authType;
}
void ContextCallbackImpl::SetTraceAuthTrustLevel(AuthTrustLevel atl)
{
metaData_.atl = atl;
}
void ContextCallbackImpl::SetCleaner(Context::ContextStopCallback callback)
{
stopCallback_ = callback;
}
void ContextCallbackNotifyListener::AddNotifier(const Notify &notify)
{
notifierList_.emplace_back(notify);
}
void ContextCallbackNotifyListener::Process(const MetaData &metaData)
{
for (const auto &notify : notifierList_) {
if (notify != nullptr) {
notify(metaData);
}
}
}
std::shared_ptr<ContextCallback> ContextCallback::NewInstance(sptr<IdmCallback> idmCallback,
OperationType operationType)
{
if (idmCallback == nullptr) {
IAM_LOGE("idmCallback is nullptr, parameter is invalid");
return nullptr;
}
return UserIAM::Common::MakeShared<ContextCallbackImpl>(idmCallback, operationType);
}
std::shared_ptr<ContextCallback> ContextCallback::NewInstance(sptr<UserAuthCallback> userAuthCallback,
OperationType operationType)
{
if (userAuthCallback == nullptr) {
IAM_LOGE("userAuthCallback is nullptr, parameter is invalid");
return nullptr;
}
return UserIAM::Common::MakeShared<ContextCallbackImpl>(userAuthCallback, operationType);
}
} // namespace UserAuth
} // namespace UserIam

21
services/context/src/context_callback_impl.h
View File

@ -16,25 +16,32 @@
#ifndef CONTEXT_CALLBACK_IMPL_H
#define CONTEXT_CALLBACK_IMPL_H
#include "context.h"
#include "user_auth_callback.h"
#include "user_idm_callback.h"
#include "context_callback.h"
namespace OHOS {
namespace UserIam {
namespace UserAuth {
class ContextCallbackImpl : public ContextCallback, public NoCopyable {
public:
explicit ContextCallbackImpl(sptr<IdmCallback> idmCallback);
explicit ContextCallbackImpl(sptr<UserAuthCallback> userAuthCallback);
explicit ContextCallbackImpl(sptr<IdmCallback> idmCallback, OperationType operationType);
explicit ContextCallbackImpl(sptr<UserAuthCallback> userAuthCallback, OperationType operationType);
~ContextCallbackImpl() override = default;
void onAcquireInfo(ExecutorRole src, int32_t moduleType, const std::vector<uint8_t> &acquireMsg) const override;
void OnResult(int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) const override;
void OnResult(int32_t resultCode, Attributes &finalResult) override;
void SetTraceUserId(int32_t userId) override;
void SetTraceRemainTime(int32_t remainTime) override;
void SetTraceFreezingTime(int32_t freezingTime) override;
void SetTraceSdkVersion(int32_t version) override;
void SetTraceCallingUid(uint64_t callingUid) override;
void SetTraceAuthType(AuthType authType) override;
void SetTraceAuthTrustLevel(AuthTrustLevel atl) override;
void SetCleaner(Context::ContextStopCallback callback) override;
private:
sptr<IdmCallback> idmCallback_;
sptr<UserAuthCallback> userAuthCallback_;
Context::ContextStopCallback stopCallback_ {nullptr};
ContextCallbackNotifyListener::MetaData metaData_;
};
} // namespace UserAuth
} // namespace UserIam

19
services/context/src/context_factory.cpp
View File

@ -33,7 +33,8 @@ namespace OHOS {
namespace UserIam {
namespace UserAuth {
std::shared_ptr<Context> ContextFactory::CreateSimpleAuthContext(int32_t userId, const std::vector<uint8_t> &challenge,
AuthType authType, AuthTrustLevel authTrustLevel, uint64_t callingUid, sptr<UserAuthCallback> &callback)
AuthType authType, AuthTrustLevel authTrustLevel, uint64_t callingUid,
const std::shared_ptr<ContextCallback> &callback)
{
IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, nullptr);
uint64_t newContextId = ContextPool::GetNewContextId();
@ -41,13 +42,11 @@ std::shared_ptr<Context> ContextFactory::CreateSimpleAuthContext(int32_t userId,
IF_FALSE_LOGE_AND_RETURN_VAL(auth != nullptr, nullptr);
auth->SetChallenge(challenge);
auth->SetCallingUid(callingUid);
auto contextCallback = MakeShared<ContextCallbackImpl>(callback);
IF_FALSE_LOGE_AND_RETURN_VAL(contextCallback != nullptr, nullptr);
return MakeShared<SimpleAuthContext>(newContextId, auth, contextCallback);
return MakeShared<SimpleAuthContext>(newContextId, auth, callback);
}
std::shared_ptr<Context> ContextFactory::CreateIdentifyContext(const std::vector<uint8_t> &challenge, AuthType authType,
uint64_t callingUid, sptr<UserAuthCallback> &callback)
uint64_t callingUid, const std::shared_ptr<ContextCallback> &callback)
{
IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, nullptr);
uint64_t newContextId = ContextPool::GetNewContextId();
@ -55,13 +54,11 @@ std::shared_ptr<Context> ContextFactory::CreateIdentifyContext(const std::vector
IF_FALSE_LOGE_AND_RETURN_VAL(identify != nullptr, nullptr);
identify->SetChallenge(challenge);
identify->SetCallingUid(callingUid);
auto contextCallback = MakeShared<ContextCallbackImpl>(callback);
IF_FALSE_LOGE_AND_RETURN_VAL(contextCallback != nullptr, nullptr);
return MakeShared<IdentifyContext>(newContextId, identify, contextCallback);
return MakeShared<IdentifyContext>(newContextId, identify, callback);
}
std::shared_ptr<Context> ContextFactory::CreateEnrollContext(int32_t userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, uint64_t callingUid, const sptr<IdmCallback> &callback)
const std::vector<uint8_t> &token, uint64_t callingUid, const std::shared_ptr<ContextCallback> &callback)
{
IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, nullptr);
uint64_t newContextId = ContextPool::GetNewContextId();
@ -70,9 +67,7 @@ std::shared_ptr<Context> ContextFactory::CreateEnrollContext(int32_t userId, Aut
enroll->SetAuthToken(token);
enroll->SetCallingUid(callingUid);
enroll->SetPinSubType(pinSubType);
auto contextCallback = MakeShared<ContextCallbackImpl>(callback);
IF_FALSE_LOGE_AND_RETURN_VAL(contextCallback != nullptr, nullptr);
return MakeShared<EnrollContext>(newContextId, enroll, contextCallback);
return MakeShared<EnrollContext>(newContextId, enroll, callback);
}
std::shared_ptr<Context> ContextFactory::CreateWidgetAuthContext(std::shared_ptr<ContextCallback> callback)

5
services/context/src/enroll_context.cpp
View File

@ -108,9 +108,8 @@ void EnrollContext::InvokeResultCallback(int32_t resultCode, const uint64_t cred
{
IAM_LOGI("%{public}s start", GetDescription());
IF_FALSE_LOGE_AND_RETURN(callback_ != nullptr);
auto finalResult = MakeShared<Attributes>();
IF_FALSE_LOGE_AND_RETURN(finalResult != nullptr);
bool setCredIdRet = finalResult->SetUint64Value(Attributes::ATTR_CREDENTIAL_ID, credentialId);
Attributes finalResult;
bool setCredIdRet = finalResult.SetUint64Value(Attributes::ATTR_CREDENTIAL_ID, credentialId);
IF_FALSE_LOGE_AND_RETURN(setCredIdRet == true);
callback_->OnResult(resultCode, finalResult);
IAM_LOGI("%{public}s invoke result callback success", GetDescription());

9
services/context/src/identify_context.cpp
View File

@ -97,14 +97,13 @@ void IdentifyContext::InvokeResultCallback(const Identification::IdentifyResultI
{
IAM_LOGI("%{public}s start", GetDescription());
IF_FALSE_LOGE_AND_RETURN(callback_ != nullptr);
auto finalResult = MakeShared<Attributes>();
IF_FALSE_LOGE_AND_RETURN(finalResult != nullptr);
bool setResultCodeRet = finalResult->SetUint32Value(Attributes::ATTR_RESULT_CODE, resultInfo.result);
Attributes finalResult;
bool setResultCodeRet = finalResult.SetUint32Value(Attributes::ATTR_RESULT_CODE, resultInfo.result);
IF_FALSE_LOGE_AND_RETURN(setResultCodeRet == true);
bool setUserIdRet = finalResult->SetInt32Value(Attributes::ATTR_USER_ID, resultInfo.userId);
bool setUserIdRet = finalResult.SetInt32Value(Attributes::ATTR_USER_ID, resultInfo.userId);
IF_FALSE_LOGE_AND_RETURN(setUserIdRet == true);
if (resultInfo.token.size() != 0) {
bool setSignatureResult = finalResult->SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, resultInfo.token);
bool setSignatureResult = finalResult.SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, resultInfo.token);
IF_FALSE_LOGE_AND_RETURN(setSignatureResult == true);
}

11
services/context/src/simple_auth_context.cpp
View File

@ -97,16 +97,15 @@ void SimpleAuthContext::InvokeResultCallback(const Authentication::AuthResultInf
{
IAM_LOGI("%{public}s start", GetDescription());
IF_FALSE_LOGE_AND_RETURN(callback_ != nullptr);
auto finalResult = MakeShared<Attributes>();
IF_FALSE_LOGE_AND_RETURN(finalResult != nullptr);
bool setResultCodeRet = finalResult->SetUint32Value(Attributes::ATTR_RESULT_CODE, resultInfo.result);
Attributes finalResult;
bool setResultCodeRet = finalResult.SetUint32Value(Attributes::ATTR_RESULT_CODE, resultInfo.result);
IF_FALSE_LOGE_AND_RETURN(setResultCodeRet == true);
bool setFreezingTimeRet = finalResult->SetInt32Value(Attributes::ATTR_FREEZING_TIME, resultInfo.freezingTime);
bool setFreezingTimeRet = finalResult.SetInt32Value(Attributes::ATTR_FREEZING_TIME, resultInfo.freezingTime);
IF_FALSE_LOGE_AND_RETURN(setFreezingTimeRet == true);
bool setUserIdRet = finalResult->SetInt32Value(Attributes::ATTR_REMAIN_TIMES, resultInfo.remainTimes);
bool setUserIdRet = finalResult.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, resultInfo.remainTimes);
IF_FALSE_LOGE_AND_RETURN(setUserIdRet == true);
if (resultInfo.token.size() != 0) {
bool setSignatureResult = finalResult->SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, resultInfo.token);
bool setSignatureResult = finalResult.SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, resultInfo.token);
IF_FALSE_LOGE_AND_RETURN(setSignatureResult == true);
}
callback_->OnResult(resultInfo.result, finalResult);

2
services/ipc/inc/user_idm_service.h
View File

@ -43,7 +43,7 @@ public:
const sptr<IdmGetCredentialInfoCallback> &callback) override;
int32_t GetSecInfo(std::optional<int32_t> userId, const sptr<IdmGetSecureUserInfoCallback> &callback) override;
void AddCredential(std::optional<int32_t> userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback) override;
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback, bool isUpdate) override;
void UpdateCredential(std::optional<int32_t> userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback) override;
int32_t Cancel(std::optional<int32_t> userId, const std::optional<std::vector<uint8_t>> &challenge) override;

56
services/ipc/src/user_auth_service.cpp
View File

@ -22,6 +22,7 @@
#include "context_helper.h"
#include "hdi_wrapper.h"
#include "iam_logger.h"
#include "iam_ptr.h"
#include "ipc_common.h"
#include "result_code.h"
#define LOG_LABEL UserIAM::Common::LABEL_USER_AUTH_SA
@ -192,41 +193,49 @@ uint64_t UserAuthService::AuthUser(std::optional<int32_t> userId, const std::vec
IAM_LOGE("callback is nullptr");
return BAD_CONTEXT_ID;
}
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER);
if (contextCallback == nullptr) {
IAM_LOGE("failed to construct context callback");
callback->OnAuthResult(GENERAL_ERROR, extraInfo);
return BAD_CONTEXT_ID;
}
auto callingUid = static_cast<uint64_t>(this->GetCallingUid());
contextCallback->SetTraceCallingUid(callingUid);
contextCallback->SetTraceAuthType(authType);
contextCallback->SetTraceAuthTrustLevel(authTrustLevel);
if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) {
IAM_LOGE("get callingUserId failed");
contextCallback->OnResult(FAIL, extraInfo);
return BAD_CONTEXT_ID;
}
contextCallback->SetTraceUserId(userId.value());
if (authTrustLevel < ATL1 || authTrustLevel > ATL4) {
IAM_LOGE("authTrustLevel is not in correct range");
callback->OnAuthResult(TRUST_LEVEL_NOT_SUPPORT, extraInfo);
contextCallback->OnResult(TRUST_LEVEL_NOT_SUPPORT, extraInfo);
return BAD_CONTEXT_ID;
}
bool checkRet = !IpcCommon::CheckPermission(*this, ACCESS_USER_AUTH_INTERNAL_PERMISSION) &&
(authType == PIN || !IpcCommon::CheckPermission(*this, ACCESS_BIOMETRIC_PERMISSION));
if (checkRet) {
IAM_LOGE("failed to check permission");
callback->OnAuthResult(CHECK_PERMISSION_FAILED, extraInfo);
contextCallback->OnResult(CHECK_PERMISSION_FAILED, extraInfo);
return BAD_CONTEXT_ID;
}
if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) {
IAM_LOGE("get callingUserId failed");
callback->OnAuthResult(FAIL, extraInfo);
return BAD_CONTEXT_ID;
}
auto callingUid = static_cast<uint64_t>(this->GetCallingUid());
auto context = ContextFactory::CreateSimpleAuthContext(userId.value(), challenge, authType, authTrustLevel,
callingUid, callback);
callingUid, contextCallback);
if (!ContextPool::Instance().Insert(context)) {
IAM_LOGE("failed to insert context");
callback->OnAuthResult(FAIL, extraInfo);
contextCallback->OnResult(FAIL, extraInfo);
return BAD_CONTEXT_ID;
}
auto cleaner = ContextHelper::Cleaner(context);
context->SetContextStopCallback(cleaner);
contextCallback->SetCleaner(cleaner);
if (!context->Start()) {
IAM_LOGE("failed to start auth");
callback->OnAuthResult(FAIL, extraInfo);
cleaner();
contextCallback->OnResult(FAIL, extraInfo);
return BAD_CONTEXT_ID;
}
return context->GetContextId();
@ -236,33 +245,38 @@ uint64_t UserAuthService::Identify(const std::vector<uint8_t> &challenge, AuthTy
sptr<UserAuthCallback> &callback)
{
IAM_LOGI("start");
Attributes extraInfo;
if (callback == nullptr) {
IAM_LOGE("callback is nullptr");
return BAD_CONTEXT_ID;
}
Attributes extraInfo;
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_IDENTIFY);
if (contextCallback == nullptr) {
IAM_LOGE("failed to construct context callback");
callback->OnIdentifyResult(GENERAL_ERROR, extraInfo);
return BAD_CONTEXT_ID;
}
if (authType == PIN) {
IAM_LOGE("pin not support");
callback->OnIdentifyResult(TYPE_NOT_SUPPORT, extraInfo);
contextCallback->OnResult(TYPE_NOT_SUPPORT, extraInfo);
return BAD_CONTEXT_ID;
}
auto callingUid = static_cast<uint64_t>(this->GetCallingUid());
auto context = ContextFactory::CreateIdentifyContext(challenge, authType, callingUid, callback);
auto context = ContextFactory::CreateIdentifyContext(challenge, authType, callingUid, contextCallback);
if (!ContextPool::Instance().Insert(context)) {
IAM_LOGE("failed to insert context");
callback->OnIdentifyResult(FAIL, extraInfo);
contextCallback->OnResult(FAIL, extraInfo);
return BAD_CONTEXT_ID;
}
auto cleaner = ContextHelper::Cleaner(context);
context->SetContextStopCallback(cleaner);
contextCallback->SetCleaner(cleaner);
if (!context->Start()) {
IAM_LOGE("failed to start identify");
callback->OnIdentifyResult(FAIL, extraInfo);
cleaner();
contextCallback->OnResult(FAIL, extraInfo);
return BAD_CONTEXT_ID;
}
return context->GetContextId();

92
services/ipc/src/user_idm_service.cpp
View File

@ -165,7 +165,7 @@ int32_t UserIdmService::GetSecInfo(std::optional<int32_t> userId, const sptr<Idm
}
void UserIdmService::AddCredential(std::optional<int32_t> userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback)
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback, bool isUpdate)
{
if (callback == nullptr) {
IAM_LOGE("callback is nullptr");
@ -173,38 +173,46 @@ void UserIdmService::AddCredential(std::optional<int32_t> userId, AuthType authT
}
Attributes extraInfo;
if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) {
IAM_LOGE("failed to get userId");
callback->OnResult(INVALID_PARAMETERS, extraInfo);
auto contextCallback = ContextCallback::NewInstance(callback,
isUpdate ? TRACE_UPDATE_CREDENTIAL : TRACE_ADD_CREDENTIAL);
if (contextCallback == nullptr) {
IAM_LOGE("failed to construct context callback");
callback->OnResult(GENERAL_ERROR, extraInfo);
return;
}
uint64_t callingUid = static_cast<uint64_t>(this->GetCallingUid());
contextCallback->SetTraceAuthType(authType);
contextCallback->SetTraceCallingUid(callingUid);
if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) {
IAM_LOGE("failed to get userId");
contextCallback->OnResult(INVALID_PARAMETERS, extraInfo);
return;
}
contextCallback->SetTraceUserId(userId.value());
if (!IpcCommon::CheckPermission(*this, MANAGE_USER_IDM_PERMISSION)) {
IAM_LOGE("failed to check permission");
callback->OnResult(CHECK_PERMISSION_FAILED, extraInfo);
contextCallback->OnResult(CHECK_PERMISSION_FAILED, extraInfo);
return;
}
std::lock_guard<std::mutex> lock(mutex_);
CancelCurrentEnrollIfExist();
uint64_t callingUid = static_cast<uint64_t>(this->GetCallingUid());
auto context =
ContextFactory::CreateEnrollContext(userId.value(), authType, pinSubType, token, callingUid, callback);
ContextFactory::CreateEnrollContext(userId.value(), authType, pinSubType, token, callingUid, contextCallback);
if (!ContextPool::Instance().Insert(context)) {
IAM_LOGE("failed to insert context");
callback->OnResult(FAIL, extraInfo);
contextCallback->OnResult(FAIL, extraInfo);
return;
}
auto cleaner = ContextHelper::Cleaner(context);
context->SetContextStopCallback(cleaner);
contextCallback->SetCleaner(cleaner);
if (!context->Start()) {
IAM_LOGE("failed to start enroll");
callback->OnResult(FAIL, extraInfo);
cleaner();
contextCallback->OnResult(FAIL, extraInfo);
}
}
@ -234,7 +242,7 @@ void UserIdmService::UpdateCredential(std::optional<int32_t> userId, AuthType au
return;
}
AddCredential(userId, authType, pinSubType, token, callback);
AddCredential(userId, authType, pinSubType, token, callback, true);
}
int32_t UserIdmService::Cancel(std::optional<int32_t> userId, const std::optional<std::vector<uint8_t>> &challenge)
@ -295,11 +303,18 @@ int32_t UserIdmService::EnforceDelUser(int32_t userId, const sptr<IdmCallback> &
CancelCurrentEnrollIfExist();
Attributes extraInfo;
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ENFORCE_DELETE_USER);
if (contextCallback == nullptr) {
IAM_LOGE("failed to construct context callback");
callback->OnResult(GENERAL_ERROR, extraInfo);
return FAIL;
}
contextCallback->SetTraceUserId(userId);
auto userInfo = UserIdmDatabase::Instance().GetSecUserInfo(userId);
if (userInfo == nullptr) {
IAM_LOGE("current userid %{public}d is not existed", userId);
callback->OnResult(INVALID_PARAMETERS, extraInfo);
contextCallback->OnResult(INVALID_PARAMETERS, extraInfo);
return INVALID_PARAMETERS;
}
@ -308,7 +323,7 @@ int32_t UserIdmService::EnforceDelUser(int32_t userId, const sptr<IdmCallback> &
if (ret != SUCCESS) {
IAM_LOGE("failed to enforce delete user");
static_cast<void>(extraInfo.SetUint64Value(Attributes::ATTR_CREDENTIAL_ID, 0));
callback->OnResult(ret, extraInfo);
contextCallback->OnResult(ret, extraInfo);
return ret;
}
@ -318,7 +333,7 @@ int32_t UserIdmService::EnforceDelUser(int32_t userId, const sptr<IdmCallback> &
}
IAM_LOGI("delete user success");
callback->OnResult(SUCCESS, extraInfo);
contextCallback->OnResult(SUCCESS, extraInfo);
return SUCCESS;
}
@ -334,15 +349,22 @@ void UserIdmService::DelUser(std::optional<int32_t> userId, const std::vector<ui
CancelCurrentEnrollIfExist();
Attributes extraInfo;
if (!IpcCommon::CheckPermission(*this, MANAGE_USER_IDM_PERMISSION)) {
IAM_LOGE("failed to check permission");
callback->OnResult(CHECK_PERMISSION_FAILED, extraInfo);
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_DELETE_USER);
if (contextCallback == nullptr) {
IAM_LOGE("failed to construct context callback");
callback->OnResult(GENERAL_ERROR, extraInfo);
return;
}
if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) {
IAM_LOGE("failed to get userId");
callback->OnResult(INVALID_PARAMETERS, extraInfo);
contextCallback->OnResult(INVALID_PARAMETERS, extraInfo);
return;
}
contextCallback->SetTraceUserId(userId.value());
if (!IpcCommon::CheckPermission(*this, MANAGE_USER_IDM_PERMISSION)) {
IAM_LOGE("failed to check permission");
contextCallback->OnResult(CHECK_PERMISSION_FAILED, extraInfo);
return;
}
@ -355,7 +377,7 @@ void UserIdmService::DelUser(std::optional<int32_t> userId, const std::vector<ui
int32_t ret = UserIdmDatabase::Instance().DeleteUser(userId.value(), authToken, credInfos);
if (ret != SUCCESS) {
IAM_LOGE("failed to delete user");
callback->OnResult(ret, extraInfo);
contextCallback->OnResult(ret, extraInfo);
return;
}
@ -365,7 +387,7 @@ void UserIdmService::DelUser(std::optional<int32_t> userId, const std::vector<ui
}
IAM_LOGI("delete user end");
callback->OnResult(ret, extraInfo);
contextCallback->OnResult(ret, extraInfo);
}
void UserIdmService::DelCredential(std::optional<int32_t> userId, uint64_t credentialId,
@ -380,15 +402,22 @@ void UserIdmService::DelCredential(std::optional<int32_t> userId, uint64_t crede
CancelCurrentEnrollIfExist();
Attributes extraInfo;
if (!IpcCommon::CheckPermission(*this, MANAGE_USER_IDM_PERMISSION)) {
IAM_LOGE("failed to check permission");
callback->OnResult(CHECK_PERMISSION_FAILED, extraInfo);
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_DELETE_CREDENTIAL);
if (contextCallback == nullptr) {
IAM_LOGE("failed to construct context callback");
callback->OnResult(GENERAL_ERROR, extraInfo);
return;
}
if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) {
IAM_LOGE("failed to get userId");
callback->OnResult(INVALID_PARAMETERS, extraInfo);
contextCallback->OnResult(INVALID_PARAMETERS, extraInfo);
return;
}
contextCallback->SetTraceUserId(userId.value());
if (!IpcCommon::CheckPermission(*this, MANAGE_USER_IDM_PERMISSION)) {
IAM_LOGE("failed to check permission");
contextCallback->OnResult(CHECK_PERMISSION_FAILED, extraInfo);
return;
}
@ -396,9 +425,12 @@ void UserIdmService::DelCredential(std::optional<int32_t> userId, uint64_t crede
auto ret = UserIdmDatabase::Instance().DeleteCredentialInfo(userId.value(), credentialId, authToken, oldInfo);
if (ret != SUCCESS) {
IAM_LOGE("failed to delete CredentialInfo");
callback->OnResult(ret, extraInfo);
contextCallback->OnResult(ret, extraInfo);
return;
}
if (oldInfo != nullptr) {
contextCallback->SetTraceAuthType(oldInfo->GetAuthType());
}
IAM_LOGI("delete credentialInfo success");
std::vector<std::shared_ptr<CredentialInfo>> list = {oldInfo};
@ -407,7 +439,7 @@ void UserIdmService::DelCredential(std::optional<int32_t> userId, uint64_t crede
IAM_LOGE("failed to delete executor info, error code : %{public}d", ret);
}
callback->OnResult(ret, extraInfo);
contextCallback->OnResult(ret, extraInfo);
}
} // namespace UserAuth
} // namespace UserIam

6
services/ipc/src/user_idm_stub.cpp
View File

@ -273,7 +273,8 @@ int32_t UserIdmStub::AddCredentialStub(MessageParcel &data, MessageParcel &reply
IAM_LOGI("auth type is pin, clear token");
token.clear();
}
AddCredential(std::nullopt, static_cast<AuthType>(authType), static_cast<PinSubType>(authSubType), token, callback);
AddCredential(std::nullopt, static_cast<AuthType>(authType), static_cast<PinSubType>(authSubType),
token, callback, false);
return SUCCESS;
}
@ -315,7 +316,8 @@ int32_t UserIdmStub::AddCredentialByIdStub(MessageParcel &data, MessageParcel &r
IAM_LOGI("auth type is pin, clear token");
token.clear();
}
AddCredential(userId, static_cast<AuthType>(authType), static_cast<PinSubType>(authSubType), token, callback);
AddCredential(userId, static_cast<AuthType>(authType), static_cast<PinSubType>(authSubType),
token, callback, false);
return SUCCESS;
}

2
test/fuzztest/services/useridmservice_fuzzer/user_idm_service_fuzzer.cpp
View File

@ -176,7 +176,7 @@ void FuzzAddCredential(Parcel &parcel)
std::vector<uint8_t> token;
FillFuzzUint8Vector(parcel, token);
sptr<IdmCallback> callback = GetFuzzIdmCallback(parcel);
g_UserIdmService.AddCredential(userId, authType, pinSubType, token, callback);
g_UserIdmService.AddCredential(userId, authType, pinSubType, token, callback, false);
IAM_LOGI("end");
}

12
test/unittest/services/mocks/mock_context.h
View File

@ -20,6 +20,7 @@
#include <gmock/gmock.h>
#include "context.h"
#include "context_callback.h"
#include "iam_ptr.h"
#include "mock_schedule_node.h"
@ -31,14 +32,21 @@ public:
virtual ~MockContextCallback() = default;
MOCK_CONST_METHOD3(
onAcquireInfo, void(ExecutorRole src, int32_t moduleType, const std::vector<uint8_t> &acquireMsg));
MOCK_CONST_METHOD2(OnResult, void(int32_t resultCode, const std::shared_ptr<Attributes> &finalResult));
MOCK_METHOD2(OnResult, void(int32_t resultCode, Attributes &finalResult));
MOCK_METHOD1(SetTraceUserId, void(int32_t userId));
MOCK_METHOD1(SetTraceRemainTime, void(int32_t remainTime));
MOCK_METHOD1(SetTraceFreezingTime, void(int32_t freezingTime));
MOCK_METHOD1(SetTraceSdkVersion, void(int32_t version));
MOCK_METHOD1(SetTraceCallingUid, void(uint64_t callingUid));
MOCK_METHOD1(SetTraceAuthType, void(AuthType authType));
MOCK_METHOD1(SetTraceAuthTrustLevel, void(AuthTrustLevel atl));
MOCK_METHOD1(SetCleaner, void(Context::ContextStopCallback callback));
};
class MockContext final : public Context {
public:
MOCK_METHOD0(Start, bool());
MOCK_METHOD0(Stop, bool());
MOCK_METHOD1(SetContextStopCallback, void(ContextStopCallback callback));
MOCK_CONST_METHOD0(GetContextId, uint64_t());
MOCK_CONST_METHOD0(GetContextType, ContextType());
MOCK_CONST_METHOD1(GetScheduleNode, std::shared_ptr<ScheduleNode>(uint64_t scheduleId));

4
test/unittest/services/mocks/mock_user_idm_service.h
View File

@ -31,8 +31,8 @@ public:
int32_t(std::optional<int32_t> userId, AuthType authType, const sptr<IdmGetCredentialInfoCallback> &callback));
MOCK_METHOD2(GetSecInfo,
int32_t(std::optional<int32_t> userId, const sptr<IdmGetSecureUserInfoCallback> &callback));
MOCK_METHOD5(AddCredential, void(std::optional<int32_t> userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback));
MOCK_METHOD6(AddCredential, void(std::optional<int32_t> userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback, bool isUpdate));
MOCK_METHOD5(UpdateCredential, void(std::optional<int32_t> userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback));
MOCK_METHOD2(Cancel, int32_t(std::optional<int32_t> userId, const std::optional<std::vector<uint8_t>> &challenge));

26
test/unittest/services/src/context_callback_impl_test.cpp
View File

@ -57,24 +57,22 @@ void ContextCallbackImplTest::TearDown()
HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthNull, TestSize.Level1)
{
sptr<UserAuthCallback> callback = nullptr;
auto contextCallback = MakeShared<ContextCallbackImpl>(callback);
sptr<UserAuthCallback> callback = new (nothrow) MockUserAuthCallback();
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
ASSERT_NE(contextCallback, nullptr);
auto testAttr = MakeShared<Attributes>();
ASSERT_TRUE(testAttr != nullptr);
Attributes attr;
contextCallback->onAcquireInfo(static_cast<ExecutorRole>(0), 0, {});
contextCallback->OnResult(0, testAttr);
contextCallback->OnResult(0, attr);
}
HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserIdmNull, TestSize.Level1)
{
sptr<IdmCallback> callback = nullptr;
auto contextCallback = MakeShared<ContextCallbackImpl>(callback);
sptr<IdmCallback> callback = new (nothrow) MockIdmCallback();
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
ASSERT_NE(contextCallback, nullptr);
auto testAttr = MakeShared<Attributes>();
ASSERT_TRUE(testAttr != nullptr);
Attributes attr;
contextCallback->onAcquireInfo(static_cast<ExecutorRole>(0), 0, {});
contextCallback->OnResult(0, testAttr);
contextCallback->OnResult(0, attr);
}
HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuth, TestSize.Level1)
@ -92,10 +90,10 @@ HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuth, TestSize.Level1)
EXPECT_TRUE(&reqRet == testAttr.get());
});
sptr<UserAuthCallback> callback = mockCallback;
auto contextCallback = MakeShared<ContextCallbackImpl>(callback);
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
ASSERT_NE(contextCallback, nullptr);
contextCallback->onAcquireInfo(static_cast<ExecutorRole>(0), 0, {});
contextCallback->OnResult(testResult, testAttr);
contextCallback->OnResult(testResult, *testAttr);
}
HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserIdmOnResult, TestSize.Level1)
@ -113,10 +111,10 @@ HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserIdmOnResult, TestSize.L
EXPECT_TRUE(&reqRet == testAttr.get());
});
sptr<IdmCallback> callback = mockCallback;
auto contextCallback = MakeShared<ContextCallbackImpl>(callback);
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
ASSERT_NE(contextCallback, nullptr);
contextCallback->onAcquireInfo(static_cast<ExecutorRole>(0), 0, {});
contextCallback->OnResult(testResult, testAttr);
contextCallback->OnResult(testResult, *testAttr);
}
} // namespace UserAuth
} // namespace UserIam

22
test/unittest/services/src/context_factory_test.cpp
View File

@ -58,8 +58,9 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateSimpleAuth_001, TestSize.Level1
std::vector<uint8_t> challenge;
sptr<UserAuthCallback> callback = new (nothrow) MockUserAuthCallback();
ASSERT_NE(callback, nullptr);
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER);
auto context = factory->CreateSimpleAuthContext(
0, challenge, static_cast<AuthType>(0), static_cast<AuthTrustLevel>(0), 0, callback);
0, challenge, static_cast<AuthType>(0), static_cast<AuthTrustLevel>(0), 0, contextCallback);
ASSERT_NE(context, nullptr);
EXPECT_NE(context->GetContextId(), 0U);
ASSERT_EQ(context->GetContextType(), CONTEXT_SIMPLE_AUTH);
@ -72,8 +73,9 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateSimpleAuth_002, TestSize.Level1
std::vector<uint8_t> challenge;
// Error: callback is null
sptr<UserAuthCallback> callback = nullptr;
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER);
auto context = factory->CreateSimpleAuthContext(
0, challenge, static_cast<AuthType>(0), static_cast<AuthTrustLevel>(0), 0, callback);
0, challenge, static_cast<AuthType>(0), static_cast<AuthTrustLevel>(0), 0, contextCallback);
ASSERT_EQ(context, nullptr);
}
@ -84,7 +86,8 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateIdentify_001, TestSize.Level1)
std::vector<uint8_t> challenge;
sptr<UserAuthCallback> callback = new (nothrow) MockUserAuthCallback();
ASSERT_NE(callback, nullptr);
auto context = factory->CreateIdentifyContext(challenge, static_cast<AuthType>(0), 0, callback);
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_IDENTIFY);
auto context = factory->CreateIdentifyContext(challenge, static_cast<AuthType>(0), 0, contextCallback);
ASSERT_NE(context, nullptr);
EXPECT_NE(context->GetContextId(), 0U);
ASSERT_EQ(context->GetContextType(), CONTEXT_IDENTIFY);
@ -97,7 +100,8 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateIdentify_002, TestSize.Level1)
std::vector<uint8_t> challenge;
// Error: callback is null
sptr<UserAuthCallback> callback = nullptr;
auto context = factory->CreateIdentifyContext(challenge, static_cast<AuthType>(0), 0, callback);
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_IDENTIFY);
auto context = factory->CreateIdentifyContext(challenge, static_cast<AuthType>(0), 0, contextCallback);
ASSERT_EQ(context, nullptr);
}
@ -108,8 +112,9 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateEnrollContext_001, TestSize.Lev
std::vector<uint8_t> token;
sptr<IdmCallback> callback = new (nothrow) MockIdmCallback();
ASSERT_NE(callback, nullptr);
auto context =
factory->CreateEnrollContext(0, static_cast<AuthType>(0), static_cast<PinSubType>(0), token, 0, callback);
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
auto context = factory->CreateEnrollContext(0, static_cast<AuthType>(0), static_cast<PinSubType>(0), token,
0, contextCallback);
ASSERT_NE(context, nullptr);
EXPECT_NE(context->GetContextId(), 0U);
ASSERT_EQ(context->GetContextType(), CONTEXT_ENROLL);
@ -122,8 +127,9 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateEnrollContext_002, TestSize.Lev
std::vector<uint8_t> token;
// Error: callback is null
sptr<IdmCallback> callback = nullptr;
auto context =
factory->CreateEnrollContext(0, static_cast<AuthType>(0), static_cast<PinSubType>(0), token, 0, callback);
auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
auto context = factory->CreateEnrollContext(0, static_cast<AuthType>(0), static_cast<PinSubType>(0), token,
0, contextCallback);
ASSERT_EQ(context, nullptr);
}
} // namespace UserAuth

12
test/unittest/services/src/enroll_context_test.cpp
View File

@ -296,7 +296,7 @@ HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_001, TestSize.Lev
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, testResultCode);
});
@ -319,7 +319,7 @@ HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_002, TestSize.Lev
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
});
@ -342,7 +342,7 @@ HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_003, TestSize.Lev
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
});
@ -374,7 +374,7 @@ HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_004, TestSize.Lev
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
});
@ -413,10 +413,10 @@ HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_005, TestSize.Lev
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::SUCCESS);
uint64_t credentialId;
bool ret = finalResult->GetUint64Value(Attributes::ATTR_CREDENTIAL_ID, credentialId);
bool ret = finalResult.GetUint64Value(Attributes::ATTR_CREDENTIAL_ID, credentialId);
EXPECT_EQ(ret, true);
EXPECT_EQ(testCredentialId, credentialId);
});

16
test/unittest/services/src/identify_context_test.cpp
View File

@ -293,7 +293,7 @@ HWTEST_F(IdentifyContextTest, IdentifyContextTest_OnScheduleStoped_001, TestSize
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, testResultCode);
});
@ -316,7 +316,7 @@ HWTEST_F(IdentifyContextTest, IdentifyContextTest_OnScheduleStoped_002, TestSize
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
});
@ -339,7 +339,7 @@ HWTEST_F(IdentifyContextTest, IdentifyContextTest_OnScheduleStoped_003, TestSize
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
});
@ -370,7 +370,7 @@ HWTEST_F(IdentifyContextTest, IdentifyContextTest_OnScheduleStoped_004, TestSize
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
});
@ -408,16 +408,16 @@ HWTEST_F(IdentifyContextTest, IdentifyContextTest_OnScheduleStoped_005, TestSize
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, testResultCode);
uint32_t attrResultCode;
int32_t userId;
vector<uint8_t> signature;
bool ret = finalResult->GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode);
bool ret = finalResult.GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode);
EXPECT_EQ(ret, true);
ret = finalResult->GetInt32Value(Attributes::ATTR_USER_ID, userId);
ret = finalResult.GetInt32Value(Attributes::ATTR_USER_ID, userId);
EXPECT_EQ(ret, true);
ret = finalResult->GetUint8ArrayValue(Attributes::ATTR_SIGNATURE, signature);
ret = finalResult.GetUint8ArrayValue(Attributes::ATTR_SIGNATURE, signature);
EXPECT_EQ(ret, true);
EXPECT_EQ(resultCode, testResultCode);

20
test/unittest/services/src/simple_auth_context_test.cpp
View File

@ -295,7 +295,7 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_OnScheduleStoped_001, Test
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, testResultCode);
});
@ -318,7 +318,7 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_OnScheduleStoped_002, Test
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
});
@ -341,7 +341,7 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_OnScheduleStoped_003, Test
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
});
@ -371,7 +371,7 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_OnScheduleStoped_004, Test
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _))
.Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR);
});
@ -410,19 +410,19 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_OnScheduleStoped_005, Test
std::shared_ptr<MockContextCallback> contextCallback = MakeShared<MockContextCallback>();
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _)).Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, testResultCode);
uint32_t attrResultCode;
int32_t freezingTime;
int32_t remainTimes;
vector<uint8_t> signature;
bool ret = finalResult->GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode);
bool ret = finalResult.GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode);
EXPECT_EQ(ret, true);
ret = finalResult->GetInt32Value(Attributes::ATTR_FREEZING_TIME, freezingTime);
ret = finalResult.GetInt32Value(Attributes::ATTR_FREEZING_TIME, freezingTime);
EXPECT_EQ(ret, true);
ret = finalResult->GetInt32Value(Attributes::ATTR_REMAIN_TIMES, remainTimes);
ret = finalResult.GetInt32Value(Attributes::ATTR_REMAIN_TIMES, remainTimes);
EXPECT_EQ(ret, true);
ret = finalResult->GetUint8ArrayValue(Attributes::ATTR_SIGNATURE, signature);
ret = finalResult.GetUint8ArrayValue(Attributes::ATTR_SIGNATURE, signature);
EXPECT_EQ(ret, true);
EXPECT_EQ(resultCode, testResultCode);
@ -464,7 +464,7 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_ContextFree, TestSize.Leve
std::shared_ptr<MockContextCallback> contextCallback = MakeShared<MockContextCallback>();
ASSERT_NE(contextCallback, nullptr);
EXPECT_CALL(*contextCallback, OnResult(_, _)).Times(Exactly(1))
.WillOnce([](int32_t resultCode, const std::shared_ptr<Attributes> &finalResult) {
.WillOnce([](int32_t resultCode, Attributes &finalResult) {
EXPECT_EQ(resultCode, ResultCode::BUSY);
});

8
test/unittest/services/src/user_idm_stub_test.cpp
View File

@ -234,10 +234,10 @@ HWTEST_F(UserIdmStubTest, UserIdmStubAddCredentialStub, TestSize.Level1)
MockUserIdmService service;
const sptr<MockIdmCallback> callback = new (std::nothrow) MockIdmCallback();
ASSERT_NE(callback, nullptr);
EXPECT_CALL(service, AddCredential(Eq(std::nullopt), PIN, PIN_SIX, IsEmpty(), _)).Times(1);
EXPECT_CALL(service, AddCredential(Eq(std::nullopt), PIN, PIN_SIX, IsEmpty(), _, true)).Times(1);
ON_CALL(service, AddCredential)
.WillByDefault([](std::optional<int32_t> userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback) {
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback, bool isUpdate) {
EXPECT_NE(callback, nullptr);
if (callback != nullptr) {
Attributes attr;
@ -265,10 +265,10 @@ HWTEST_F(UserIdmStubTest, UserIdmStubAddCredentialByIdStub, TestSize.Level1)
MockUserIdmService service;
const sptr<MockIdmCallback> callback = new (std::nothrow) MockIdmCallback();
ASSERT_NE(callback, nullptr);
EXPECT_CALL(service, AddCredential(Eq(IDM_STUB_TEST_USER_ID), PIN, PIN_SIX, IsEmpty(), _)).Times(1);
EXPECT_CALL(service, AddCredential(Eq(IDM_STUB_TEST_USER_ID), PIN, PIN_SIX, IsEmpty(), _, true)).Times(1);
ON_CALL(service, AddCredential)
.WillByDefault([](std::optional<int32_t> userId, AuthType authType, PinSubType pinSubType,
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback) {
const std::vector<uint8_t> &token, const sptr<IdmCallback> &callback, bool isUpdate) {
EXPECT_NE(callback, nullptr);
if (callback != nullptr) {
Attributes attr;