Support multiple instances with different user_ids concurrently

Change-Id: Ifc2f4e89ff6bc04da6426873573a961c4a0f9d79

diff --git a/src/hal_backend_security_auth.cpp b/src/hal_backend_security_auth.cpp
index 0b812346069e87939b52af9ba2cf4bd7e62dc573..9717954ef13171dc26887a4d7bcf1b759973da32 100644 (file)
--- a/src/hal_backend_security_auth.cpp
+++ b/src/hal_backend_security_auth.cpp
@@ -239,8 +239,6 @@ void hal_backend_security_auth::prepare_attempt_file()
 int hal_backend_security_auth::write_memory_to_file(uid_t user_id) const
 {
        LOGD("hal_backend_security_auth::write_memory_to_file user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        std::string pwdFile = create_dir(RW_DATA_DIR, m_user) + PASSWORD_FILE;
        PasswordFileBuffer pwdBuffer;
        LOGD("m_user : " << m_user << " m_maxAttempt : " << m_maxAttempt << " m_maxHistorySize : "
@@ -269,8 +267,6 @@ int hal_backend_security_auth::write_memory_to_file(uid_t user_id) const
 int hal_backend_security_auth::write_attempt_to_file(uid_t user_id) const
 {
        LOGD("hal_backend_security_auth::write_attempt_to_file user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        std::string attemptFile = create_dir(RW_DATA_DIR, m_user) + ATTEMPT_FILE;
        std::ofstream AttemptFile(attemptFile, std::ofstream::trunc);
 
@@ -295,8 +291,6 @@ int hal_backend_security_auth::write_attempt_to_file(uid_t user_id) const
 int hal_backend_security_auth::set_password(uid_t user_id, const char* password)
 {
        LOGD("hal_backend_security_auth::set_password user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user || password == nullptr)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        if (password[0] == '\0') {
                m_passwordCurrent.reset(new NoPassword());
                m_passwordActive = false;
@@ -318,8 +312,8 @@ int hal_backend_security_auth::set_password(uid_t user_id, const char* password)
 
 int hal_backend_security_auth::check_password(uid_t user_id, const char* password)
 {
-       LOGD("hal_backend_security_auth::check_password");
-       if(user_id != m_user || password == nullptr)
+       LOGD("hal_backend_security_auth::check_password user_id : " << user_id);
+       if(password == nullptr)
                return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        return m_passwordCurrent->match(password) ? HAL_SECURITY_AUTH_ERROR_NONE : HAL_SECURITY_AUTH_ERROR_PASSWORD_MISMATCH;
 }
@@ -327,8 +321,6 @@ int hal_backend_security_auth::check_password(uid_t user_id, const char* passwor
 int hal_backend_security_auth::set_max_history_size(uid_t user_id, unsigned int history_size)
 {
        LOGD("hal_backend_security_auth::set_max_history_size user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        // put current password in history
        if (m_maxHistorySize == 0 && history_size > 0)
                m_passwordHistory.push_front(m_passwordCurrent);
@@ -346,8 +338,6 @@ int hal_backend_security_auth::set_max_history_size(uid_t user_id, unsigned int
 int hal_backend_security_auth::get_max_history_size(uid_t user_id, unsigned int *history_size) const
 {
        LOGD("hal_backend_security_auth::get_max_history_size user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        *history_size = m_maxHistorySize;
        LOGD("m_maxHistorySize : " << m_maxHistorySize);
 
@@ -357,8 +347,6 @@ int hal_backend_security_auth::get_max_history_size(uid_t user_id, unsigned int
 int hal_backend_security_auth::get_expire_time(uid_t user_id, unsigned int *expire_time) const
 {
        LOGD("hal_backend_security_auth::get_expire_time user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        *expire_time = m_expireTime;
        LOGD("m_expireTime : " << m_expireTime);
 
@@ -368,8 +356,6 @@ int hal_backend_security_auth::get_expire_time(uid_t user_id, unsigned int *expi
 int hal_backend_security_auth::set_expire_time(uid_t user_id, unsigned int expire_time)
 {
        LOGD("hal_backend_security_auth::set_expire_time user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        m_expireTime = expire_time;
        LOGD("m_expireTime : " << m_expireTime);
 
@@ -379,8 +365,6 @@ int hal_backend_security_auth::set_expire_time(uid_t user_id, unsigned int expir
 int hal_backend_security_auth::get_attempt(uid_t user_id, unsigned int *attempt) const
 {
        LOGD("hal_backend_security_auth::get_attempt user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        *attempt = m_attempt;
        LOGD("m_attempt : " << m_attempt);
        return HAL_SECURITY_AUTH_ERROR_NONE;
@@ -389,8 +373,6 @@ int hal_backend_security_auth::get_attempt(uid_t user_id, unsigned int *attempt)
 int hal_backend_security_auth::set_expire_time_left(uid_t user_id, unsigned int expire_time_left)
 {
        LOGD("hal_backend_security_auth::set_expire_time_left user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        m_expireTimeLeft = expire_time_left;
        LOGD("expire_time_left : " << expire_time_left);
 
@@ -401,8 +383,6 @@ int hal_backend_security_auth::get_expire_time_left(uid_t user_id, unsigned int
 {
        LOGD("hal_backend_security_auth::get_expire_time_left user_id : " << user_id << " m_user : " << m_user);
        //calculate left secs by the time of password expiration
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        if (m_expireTimeLeft != PASSWORD_INFINITE_EXPIRATION_TIME) {
                LOGD("Not Equal m_expireTimeLeft : " << m_expireTimeLeft << " vs PASSWORD_INFINITE_EXPIRATION_TIME : "
                        << PASSWORD_INFINITE_EXPIRATION_TIME);
@@ -422,8 +402,6 @@ int hal_backend_security_auth::get_expire_time_left(uid_t user_id, unsigned int
 int hal_backend_security_auth::reset_attempt(uid_t user_id)
 {
        LOGD("hal_backend_security_auth::reset_attempt user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        m_attempt = 0;
 
        return HAL_SECURITY_AUTH_ERROR_NONE;
@@ -432,8 +410,6 @@ int hal_backend_security_auth::reset_attempt(uid_t user_id)
 int hal_backend_security_auth::increment_attempt(uid_t user_id)
 {
        LOGD("hal_backend_security_auth::increment_attempt user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        m_attempt++;
        LOGD("m_attempt : " << m_attempt);
 
@@ -443,8 +419,6 @@ int hal_backend_security_auth::increment_attempt(uid_t user_id)
 int hal_backend_security_auth::get_max_attempt(uid_t user_id, unsigned int *max_attempt) const
 {
        LOGD("hal_backend_security_auth::get_max_attempt user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        *max_attempt = m_maxAttempt;
        LOGD("*m_maxAttempt : " << m_maxAttempt);
 
@@ -454,9 +428,6 @@ int hal_backend_security_auth::get_max_attempt(uid_t user_id, unsigned int *max_
 int hal_backend_security_auth::set_max_attempt(uid_t user_id, unsigned int max_attempt)
 {
        LOGD("hal_backend_security_auth::set_max_attempt user_id : " << user_id << " m_user : " << m_user);
-
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        m_maxAttempt = max_attempt;
        LOGD("max_attempt : " << max_attempt);
 
@@ -466,16 +437,12 @@ int hal_backend_security_auth::set_max_attempt(uid_t user_id, unsigned int max_a
 int hal_backend_security_auth::is_password_active(uid_t user_id) const
 {
        LOGD("hal_backend_security_auth::is_password_active user_id : " << user_id << " m_user : " << m_user <<" m_passwordActive : " << m_passwordActive);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        return m_passwordActive ? HAL_SECURITY_AUTH_ERROR_NONE : HAL_SECURITY_AUTH_ERROR_STATUS;
 }
 
 int hal_backend_security_auth::is_password_reused(uid_t user_id, const char* password) const
 {
        LOGD("hal_backend_security_auth::is_password_reused user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        LOGD("m_passwordHistory : " << m_passwordHistory.size() << " m_maxHistorySize : " << m_maxHistorySize);
 
        // go through history and check if password existed earlier
@@ -496,8 +463,6 @@ int hal_backend_security_auth::is_password_reused(uid_t user_id, const char* pas
 int hal_backend_security_auth::check_expiration(uid_t user_id) const
 {
        LOGD("hal_backend_security_auth::check_expiration user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        LOGD("m_expireTimeLeft : " << m_expireTimeLeft << " PASSWORD_INFINITE_EXPIRATION_TIME : "
                << PASSWORD_INFINITE_EXPIRATION_TIME << " time : " << time(NULL) << " m_expireTimeLeft : " << m_expireTimeLeft);
        return ((m_expireTimeLeft != PASSWORD_INFINITE_EXPIRATION_TIME) && (time(NULL) > m_expireTimeLeft)) ? HAL_SECURITY_AUTH_ERROR_PASSWORD_EXPIRED : HAL_SECURITY_AUTH_ERROR_NONE;
@@ -508,16 +473,12 @@ int hal_backend_security_auth::check_attempt_exceeded(uid_t user_id) const
        LOGD("hal_backend_security_auth::check_attempt_exceeded user_id : " << user_id << " m_user : " << m_user);
        LOGD("m_maxAttempt : " << m_maxAttempt << " PASSWORD_INFINITE_ATTEMPT_COUNT : " << PASSWORD_INFINITE_ATTEMPT_COUNT
                << " m_attempt : " << m_attempt);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        return ((m_maxAttempt != PASSWORD_INFINITE_ATTEMPT_COUNT) && (m_attempt > m_maxAttempt)) ? HAL_SECURITY_AUTH_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED : HAL_SECURITY_AUTH_ERROR_NONE;
 }
 
 int hal_backend_security_auth::is_ignore_period(uid_t user_id) const
 {
        LOGD("hal_backend_security_auth::is_ignore_period user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        TimePoint retryTimerStop = ClockType::now();
        TimeDiff diff = retryTimerStop - m_retryTimerStart;
        m_retryTimerStart = retryTimerStop;
@@ -529,8 +490,6 @@ int hal_backend_security_auth::is_ignore_period(uid_t user_id) const
 int hal_backend_security_auth::is_history_active(uid_t user_id) const
 {
        LOGD("hal_backend_security_auth::is_history_active user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        LOGD( "m_maxHistorySize : " << m_maxHistorySize);
        return (m_maxHistorySize != 0) ? HAL_SECURITY_AUTH_ERROR_NONE : HAL_SECURITY_AUTH_ERROR_STATUS;
 }
@@ -539,8 +498,6 @@ int hal_backend_security_auth::get_password_type(uid_t user_id,
                                                                                                 hal_security_auth_password_type_e *password_type) const
 {
        LOGD("hal_backend_security_auth::get_password_type user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        *password_type = m_passwordType;
        LOGD( "m_passwordType : " << m_passwordType);
        return HAL_SECURITY_AUTH_ERROR_NONE;
@@ -550,8 +507,6 @@ int hal_backend_security_auth::set_password_type(uid_t user_id,
                                                                                                 hal_security_auth_password_type_e password_type)
 {
        LOGD("hal_backend_security_auth::set_password_type user_id : " << user_id << " m_user : " << m_user);
-       if(user_id != m_user)
-               return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
        m_passwordType = password_type;
        LOGD( "passwordType : " << password_type);
        return HAL_SECURITY_AUTH_ERROR_NONE;
@@ -601,6 +556,18 @@ hal_backend_security_auth* get_hal_backend_security_auth_instance(uid_t user_id,
        return new_security_auth;
 }
 
+hal_backend_security_auth* get_hal_backend_security_auth_instance_with_user(uid_t user_id)
+{
+       auto itAuth = hal_backend_security_auth_instance_map.find(user_id);
+       LOGD("get_hal_backend_security_auth_instance_with_user user_id : " << user_id);
+
+       if (itAuth != hal_backend_security_auth_instance_map.end()){
+               hal_backend_security_auth *authInstance = itAuth->second;
+               return authInstance;
+       }
+       return nullptr;
+}
+
 #ifdef __cplusplus
 }
 #endif
\ No newline at end of file

diff --git a/src/hal_backend_security_auth.h b/src/hal_backend_security_auth.h
index b92b97e21a10c8bc562c4dddb3c4198e0d57c69d..32df3481f2da1370b7e72b2b3e874a439230e96d 100644 (file)
--- a/src/hal_backend_security_auth.h
+++ b/src/hal_backend_security_auth.h
@@ -127,6 +127,7 @@ class hal_backend_security_auth : public IPasswordFile {
 };
 
 hal_backend_security_auth* get_hal_backend_security_auth_instance(uid_t user_id, hal_security_auth_password_type_e password_type);
+hal_backend_security_auth* get_hal_backend_security_auth_instance_with_user(uid_t user_id);
 
 #ifdef __cplusplus
 }

diff --git a/src/hal_backend_security_auth_api.cpp b/src/hal_backend_security_auth_api.cpp
index f3f2540f48636285764a822ba38bdf37ea813efe..13284cdfa129d800e1e5979bbf9a3734dc3b9efc 100644 (file)
--- a/src/hal_backend_security_auth_api.cpp
+++ b/src/hal_backend_security_auth_api.cpp
@@ -22,125 +22,145 @@
 
 #define EXPORT __attribute__ ((visibility("default")))
 
-static hal_backend_security_auth *g_auth_instance = nullptr;
-
 int security_auth_create_password_file(uid_t user_id,
                                                                  hal_security_auth_password_type_e password_type)
 {
        LOGD("security_auth_create_password_file");
-       g_auth_instance = get_hal_backend_security_auth_instance(user_id, password_type);
-       return g_auth_instance ? HAL_SECURITY_AUTH_ERROR_NONE: HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance(user_id, password_type);
+       return auth_instance ? HAL_SECURITY_AUTH_ERROR_NONE: HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
 }
 
 int security_auth_write_memory_to_file(uid_t user_id)
 {
-       return g_auth_instance ? g_auth_instance->write_memory_to_file(user_id) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->write_memory_to_file(user_id) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_write_attempt_to_file(uid_t user_id)
 {
-       return g_auth_instance ? g_auth_instance->write_attempt_to_file(user_id) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->write_attempt_to_file(user_id) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_set_password(uid_t user_id, const char* password)
 {
-       return g_auth_instance ? g_auth_instance->set_password(user_id, password) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->set_password(user_id, password) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_check_password(uid_t user_id, const char* password)
 {
-       return g_auth_instance ? g_auth_instance->check_password(user_id, password) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->check_password(user_id, password) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_set_max_history_size(uid_t user_id, unsigned int history_size)
 {
-       return g_auth_instance ? g_auth_instance->set_max_history_size(user_id, history_size) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->set_max_history_size(user_id, history_size) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_get_max_history_size(uid_t user_id, unsigned int *history_size)
 {
-       return g_auth_instance ? g_auth_instance->get_max_history_size(user_id, history_size) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->get_max_history_size(user_id, history_size) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_get_expire_time(uid_t user_id, unsigned int *expire_time)
 {
-       return g_auth_instance ? g_auth_instance->get_expire_time(user_id, expire_time) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->get_expire_time(user_id, expire_time) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_set_expire_time(uid_t user_id, unsigned int expire_time)
 {
-       return g_auth_instance ? g_auth_instance->set_expire_time(user_id, expire_time) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->set_expire_time(user_id, expire_time) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_get_attempt(uid_t user_id, unsigned int *attempt)
 {
-       return g_auth_instance ? g_auth_instance->get_attempt(user_id, attempt) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->get_attempt(user_id, attempt) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_reset_attempt(uid_t user_id)
 {
-       return g_auth_instance ? g_auth_instance->reset_attempt(user_id) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->reset_attempt(user_id) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_increment_attempt(uid_t user_id)
 {
-       return g_auth_instance ? g_auth_instance->increment_attempt(user_id) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->increment_attempt(user_id) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_get_max_attempt(uid_t user_id, unsigned int *max_attempt)
 {
-       return g_auth_instance ? g_auth_instance->get_max_attempt(user_id, max_attempt) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->get_max_attempt(user_id, max_attempt) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_set_max_attempt(uid_t user_id, unsigned int max_attempt)
 {
-       return g_auth_instance ? g_auth_instance->set_max_attempt(user_id, max_attempt) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->set_max_attempt(user_id, max_attempt) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_get_expire_time_left(uid_t user_id, unsigned int *expire_time_left)
 {
-       return g_auth_instance ? g_auth_instance->get_expire_time_left(user_id, expire_time_left) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->get_expire_time_left(user_id, expire_time_left) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_set_expire_time_left(uid_t user_id, unsigned int expire_time_left)
 {
-       return g_auth_instance ? g_auth_instance->set_expire_time_left(user_id, expire_time_left) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->set_expire_time_left(user_id, expire_time_left) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_is_password_active(uid_t user_id)
 {
-       return g_auth_instance ? g_auth_instance->is_password_active(user_id) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->is_password_active(user_id) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_is_password_reused(uid_t user_id, const char* password)
 {
-       return g_auth_instance ? g_auth_instance->is_password_reused(user_id, password) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->is_password_reused(user_id, password) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_check_expiration(uid_t user_id)
 {
-       return g_auth_instance ? g_auth_instance->check_expiration(user_id) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->check_expiration(user_id) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_check_attempt_exceeded(uid_t user_id)
 {
-       return g_auth_instance ? g_auth_instance->check_attempt_exceeded(user_id) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->check_attempt_exceeded(user_id) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_is_ignore_period(uid_t user_id)
 {
-       return g_auth_instance ? g_auth_instance->is_ignore_period(user_id) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->is_ignore_period(user_id) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_is_history_active(uid_t user_id)
 {
-       return g_auth_instance ? g_auth_instance->is_history_active(user_id) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->is_history_active(user_id) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 int security_auth_get_password_type(uid_t user_id,
                                                           hal_security_auth_password_type_e *password_type)
 {
-       return g_auth_instance ? g_auth_instance->get_password_type(user_id, password_type) : HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
+       hal_backend_security_auth *auth_instance = get_hal_backend_security_auth_instance_with_user(user_id);
+       return auth_instance ? auth_instance->get_password_type(user_id, password_type) : HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 }
 
 static int security_auth_backend_init(void **data)