1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 18 #include "securec.h" 19 20 #include "adaptor_time.h" 21 #include "defines.h" 22 #include "idm_session.h" 23 24 extern "C" { 25 extern struct SessionInfo { 26 int32_t userId; 27 uint32_t authType; 28 uint64_t time; 29 uint64_t validAuthTokenTime; 30 uint8_t challenge[CHALLENGE_LEN]; 31 uint64_t scheduleId; 32 ScheduleType scheduleType; 33 bool isScheduleValid; 34 PinChangeScence pinChangeScence; 35 Buffer *oldRootSecret; 36 Buffer *curRootSecret; 37 Buffer *newRootSecret; 38 } *g_session; 39 extern ResultCode GenerateChallenge(uint8_t *challenge, uint32_t challengeLen); 40 } 41 42 namespace OHOS { 43 namespace UserIam { 44 namespace UserAuth { 45 using namespace testing; 46 using namespace testing::ext; 47 48 class IdmSessionTest : public testing::Test { 49 public: SetUpTestCase()50 static void SetUpTestCase() {}; 51 TearDownTestCase()52 static void TearDownTestCase() {}; 53 SetUp()54 void SetUp() {}; 55 TearDown()56 void TearDown() {}; 57 }; 58 59 HWTEST_F(IdmSessionTest, TestOpenEditSession, TestSize.Level0) 60 { 61 EXPECT_EQ(OpenEditSession(0, nullptr, 0), RESULT_BAD_PARAM); 62 } 63 64 HWTEST_F(IdmSessionTest, TestRefreshValidTokenTime, TestSize.Level0) 65 { 66 g_session = nullptr; 67 RefreshValidTokenTime(); 68 struct SessionInfo session = {}; 69 g_session = &session; 70 RefreshValidTokenTime(); 71 EXPECT_LE(g_session->validAuthTokenTime, GetSystemTime()); 72 g_session = nullptr; 73 } 74 75 HWTEST_F(IdmSessionTest, TestIsValidTokenTime, TestSize.Level0) 76 { 77 g_session = nullptr; 78 EXPECT_FALSE(IsValidTokenTime(0)); 79 } 80 81 HWTEST_F(IdmSessionTest, TestGetUserId, TestSize.Level0) 82 { 83 g_session = nullptr; 84 EXPECT_EQ(GetUserId(nullptr), RESULT_BAD_PARAM); 85 int32_t userId = 0; 86 EXPECT_EQ(GetUserId(&userId), RESULT_BAD_PARAM); 87 } 88 89 HWTEST_F(IdmSessionTest, TestCheckChallenge_001, TestSize.Level0) 90 { 91 g_session = nullptr; 92 EXPECT_EQ(CheckChallenge(nullptr, 0), RESULT_BAD_PARAM); 93 uint8_t challenge = 0; 94 EXPECT_EQ(CheckChallenge(&challenge, 0), RESULT_BAD_PARAM); 95 EXPECT_EQ(CheckChallenge(&challenge, CHALLENGE_LEN), RESULT_NEED_INIT); 96 } 97 98 HWTEST_F(IdmSessionTest, TestCheckChallenge_002, TestSize.Level0) 99 { 100 uint8_t challenge[CHALLENGE_LEN]; 101 EXPECT_EQ(memset_s(challenge, CHALLENGE_LEN, 0, CHALLENGE_LEN), EOK); 102 struct SessionInfo session; 103 EXPECT_EQ(GenerateChallenge(session.challenge, CHALLENGE_LEN), RESULT_SUCCESS); 104 g_session = &session; 105 EXPECT_EQ(CheckChallenge(challenge, CHALLENGE_LEN), RESULT_BAD_MATCH); 106 g_session = nullptr; 107 } 108 109 HWTEST_F(IdmSessionTest, TestAssociateCoauthSchedule, TestSize.Level0) 110 { 111 g_session = nullptr; 112 EXPECT_EQ(AssociateCoauthSchedule(0, 0, SCHEDULE_TYPE_ENROLL), RESULT_NEED_INIT); 113 } 114 115 HWTEST_F(IdmSessionTest, TestGetEnrollScheduleInfo_001, TestSize.Level0) 116 { 117 EXPECT_EQ(GetEnrollScheduleInfo(nullptr, nullptr), RESULT_BAD_PARAM); 118 uint64_t scheduleId = 0; 119 EXPECT_EQ(GetEnrollScheduleInfo(&scheduleId, nullptr), RESULT_BAD_PARAM); 120 } 121 122 HWTEST_F(IdmSessionTest, TestGetEnrollScheduleInfo_002, TestSize.Level0) 123 { 124 g_session = nullptr; 125 uint64_t scheduleId = 0; 126 uint32_t authType = 1; 127 EXPECT_EQ(GetEnrollScheduleInfo(&scheduleId, &authType), RESULT_NEED_INIT); 128 struct SessionInfo session; 129 session.isScheduleValid = false; 130 g_session = &session; 131 EXPECT_EQ(GetEnrollScheduleInfo(&scheduleId, &authType), RESULT_NEED_INIT); 132 session.isScheduleValid = true; 133 EXPECT_EQ(GetEnrollScheduleInfo(&scheduleId, &authType), RESULT_SUCCESS); 134 g_session = nullptr; 135 } 136 137 HWTEST_F(IdmSessionTest, TestCheckSessionTimeout, TestSize.Level0) 138 { 139 g_session = nullptr; 140 EXPECT_EQ(CheckSessionTimeout(), RESULT_NEED_INIT); 141 struct SessionInfo session; 142 session.time = UINT64_MAX; 143 g_session = &session; 144 EXPECT_EQ(CheckSessionTimeout(), RESULT_GENERAL_ERROR); 145 g_session = nullptr; 146 } 147 148 HWTEST_F(IdmSessionTest, TestGetScheduleType, TestSize.Level0) 149 { 150 EXPECT_EQ(GetScheduleType(nullptr), RESULT_BAD_PARAM); 151 } 152 153 HWTEST_F(IdmSessionTest, TestCheckSessionValid, TestSize.Level0) 154 { 155 struct SessionInfo session; 156 constexpr int32_t userId = 2135; 157 session.userId = userId; 158 session.time = UINT64_MAX; 159 g_session = &session; 160 EXPECT_EQ(CheckSessionValid(0), RESULT_GENERAL_ERROR); 161 session.time = GetSystemTime(); 162 EXPECT_EQ(CheckSessionValid(0), RESULT_GENERAL_ERROR); 163 g_session = nullptr; 164 } 165 166 HWTEST_F(IdmSessionTest, TestGetChallenge, TestSize.Level0) 167 { 168 constexpr uint32_t arrayLen = 32; 169 uint8_t challengeArray[arrayLen] = {}; 170 EXPECT_EQ(GetChallenge(nullptr, 0), RESULT_BAD_PARAM); 171 EXPECT_EQ(GetChallenge(nullptr, arrayLen), RESULT_BAD_PARAM); 172 EXPECT_EQ(GetChallenge(challengeArray, arrayLen), RESULT_NEED_INIT); 173 } 174 175 HWTEST_F(IdmSessionTest, TestGetCurRootSecret, TestSize.Level0) 176 { 177 LOG_INFO("start"); 178 struct SessionInfo session; 179 constexpr int32_t userId = 1; 180 session.userId = userId; 181 session.time = GetSystemTime(); 182 session.oldRootSecret = nullptr; 183 session.curRootSecret = nullptr; 184 session.newRootSecret = nullptr; 185 g_session = &session; 186 Buffer *rootSecret = GetCurRootSecret(0); 187 EXPECT_EQ(rootSecret, nullptr); 188 rootSecret = GetCurRootSecret(userId); 189 EXPECT_EQ(rootSecret, nullptr); 190 g_session = NULL; 191 LOG_INFO("end"); 192 } 193 194 HWTEST_F(IdmSessionTest, TestSetCurRootSecret, TestSize.Level0) 195 { 196 LOG_INFO("start"); 197 struct SessionInfo session; 198 constexpr int32_t userId = 1; 199 session.userId = userId; 200 session.time = GetSystemTime(); 201 session.oldRootSecret = nullptr; 202 session.curRootSecret = nullptr; 203 session.newRootSecret = nullptr; 204 g_session = &session; 205 SetCurRootSecret(0, nullptr); 206 EXPECT_EQ(GetCurRootSecret(userId), nullptr); 207 SetCurRootSecret(userId, nullptr); 208 EXPECT_EQ(GetCurRootSecret(userId), nullptr); 209 constexpr int32_t dataLen = 32; 210 Buffer *test = CreateBufferBySize(dataLen); 211 test->contentSize = dataLen; 212 SetCurRootSecret(userId, test); 213 EXPECT_NE(GetCurRootSecret(userId), nullptr); 214 DestoryBuffer(test); 215 g_session = NULL; 216 LOG_INFO("end"); 217 } 218 219 HWTEST_F(IdmSessionTest, TestIsValidUserType, TestSize.Level0) 220 { 221 constexpr int32_t userType = 1024; 222 EXPECT_EQ(IsValidUserType(userType), RESULT_BAD_PARAM); 223 } 224 225 HWTEST_F(IdmSessionTest, TestGetOldRootSecret, TestSize.Level0) 226 { 227 LOG_INFO("start"); 228 struct SessionInfo session; 229 constexpr int32_t userId = 1; 230 session.userId = userId; 231 session.time = GetSystemTime(); 232 session.oldRootSecret = nullptr; 233 session.curRootSecret = nullptr; 234 session.newRootSecret = nullptr; 235 g_session = &session; 236 Buffer *rootSecret = GetOldRootSecret(0); 237 EXPECT_EQ(rootSecret, nullptr); 238 rootSecret = GetOldRootSecret(userId); 239 EXPECT_EQ(rootSecret, nullptr); 240 g_session = NULL; 241 LOG_INFO("end"); 242 } 243 244 HWTEST_F(IdmSessionTest, TestSetOldRootSecret, TestSize.Level0) 245 { 246 LOG_INFO("start"); 247 struct SessionInfo session; 248 constexpr int32_t userId = 1; 249 session.userId = userId; 250 session.time = GetSystemTime(); 251 session.oldRootSecret = nullptr; 252 session.curRootSecret = nullptr; 253 session.newRootSecret = nullptr; 254 g_session = &session; 255 SetOldRootSecret(0, nullptr); 256 EXPECT_EQ(GetOldRootSecret(userId), nullptr); 257 SetOldRootSecret(userId, nullptr); 258 EXPECT_EQ(GetOldRootSecret(userId), nullptr); 259 constexpr int32_t dataLen = 32; 260 Buffer *test = CreateBufferBySize(dataLen); 261 test->contentSize = dataLen; 262 SetOldRootSecret(userId, test); 263 EXPECT_NE(GetOldRootSecret(userId), nullptr); 264 DestoryBuffer(test); 265 g_session = NULL; 266 LOG_INFO("end"); 267 } 268 269 HWTEST_F(IdmSessionTest, TestGetNewRootSecret, TestSize.Level0) 270 { 271 LOG_INFO("start"); 272 struct SessionInfo session; 273 constexpr int32_t userId = 1; 274 session.userId = userId; 275 session.time = GetSystemTime(); 276 session.oldRootSecret = nullptr; 277 session.curRootSecret = nullptr; 278 session.newRootSecret = nullptr; 279 g_session = &session; 280 Buffer *rootSecret = GetNewRootSecret(0); 281 EXPECT_EQ(rootSecret, nullptr); 282 rootSecret = GetNewRootSecret(userId); 283 EXPECT_EQ(rootSecret, nullptr); 284 g_session = NULL; 285 LOG_INFO("end"); 286 } 287 288 HWTEST_F(IdmSessionTest, TestSetNewRootSecret, TestSize.Level0) 289 { 290 LOG_INFO("start"); 291 struct SessionInfo session; 292 constexpr int32_t userId = 1; 293 session.userId = userId; 294 session.time = GetSystemTime(); 295 session.oldRootSecret = nullptr; 296 session.curRootSecret = nullptr; 297 session.newRootSecret = nullptr; 298 g_session = &session; 299 EXPECT_EQ(SetNewRootSecret(0, nullptr), RESULT_GENERAL_ERROR); 300 EXPECT_EQ(GetNewRootSecret(userId), nullptr); 301 EXPECT_EQ(SetNewRootSecret(userId, nullptr), RESULT_GENERAL_ERROR); 302 EXPECT_EQ(GetNewRootSecret(userId), nullptr); 303 constexpr int32_t dataLen = 32; 304 Buffer *test = CreateBufferBySize(dataLen); 305 test->contentSize = dataLen; 306 EXPECT_EQ(SetNewRootSecret(userId, test), RESULT_SUCCESS); 307 EXPECT_NE(GetNewRootSecret(userId), nullptr); 308 DestoryBuffer(test); 309 g_session = NULL; 310 LOG_INFO("end"); 311 } 312 313 HWTEST_F(IdmSessionTest, TestGetPinChangeScence, TestSize.Level0) 314 { 315 LOG_INFO("start"); 316 struct SessionInfo session; 317 constexpr int32_t userId = 2135; 318 session.userId = userId; 319 session.time = GetSystemTime(); 320 session.pinChangeScence = PIN_UPDATE_SCENCE; 321 g_session = &session; 322 PinChangeScence pinChangeScence = GetPinChangeScence(0); 323 EXPECT_EQ(pinChangeScence, 0); 324 pinChangeScence = GetPinChangeScence(userId); 325 EXPECT_EQ(pinChangeScence, 0); 326 g_session = NULL; 327 LOG_INFO("end"); 328 } 329 330 HWTEST_F(IdmSessionTest, TestSetPinChangeScence, TestSize.Level0) 331 { 332 LOG_INFO("start"); 333 struct SessionInfo session; 334 constexpr int32_t userId = 2135; 335 session.userId = userId; 336 session.time = GetSystemTime(); 337 session.pinChangeScence = PIN_UPDATE_SCENCE; 338 session.authType = PIN_AUTH; 339 g_session = &session; 340 SetPinChangeScence(0, DEFUALT); 341 SetPinChangeScence(userId, DEFUALT); 342 PinChangeScence pinChangeScence = GetPinChangeScence(userId); 343 EXPECT_EQ(pinChangeScence, PIN_UPDATE_SCENCE); 344 SetPinChangeScence(userId, ABANDONED_PIN_AUTH); 345 pinChangeScence = GetPinChangeScence(userId); 346 EXPECT_EQ(pinChangeScence, PIN_RESET_SCENCE); 347 g_session = NULL; 348 LOG_INFO("end"); 349 } 350 } // namespace UserAuth 351 } // namespace UserIam 352 } // namespace OHOS 353