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 "pin_db_test.h"
17
18 #include "pin_db.h"
19 #include "securec.h"
20
21 namespace OHOS {
22 namespace UserIam {
23 namespace PinAuth {
24 using namespace testing;
25 using namespace testing::ext;
26 namespace {
27 constexpr uint32_t ROOT_SECRET_LEN = 32U;
28 }
29
SetUpTestCase()30 void PinDataBaseTest::SetUpTestCase()
31 {
32 }
33
TearDownTestCase()34 void PinDataBaseTest::TearDownTestCase()
35 {
36 }
37
SetUp()38 void PinDataBaseTest::SetUp()
39 {
40 }
41
TearDown()42 void PinDataBaseTest::TearDown()
43 {
44 }
45
46 /**
47 * @tc.name: AddAndAuth test
48 * @tc.desc: verify AddAndAuth
49 * @tc.type: FUNC
50 * @tc.require: #I64XCB
51 */
52 HWTEST_F(PinDataBaseTest, AddAndAuth_test, TestSize.Level1)
53 {
54 PinEnrollParam *pinEnrollParam = new (std::nothrow) PinEnrollParam();
55 EXPECT_NE(pinEnrollParam, nullptr);
56
57 pinEnrollParam->scheduleId = 1;
58 pinEnrollParam->subType = 10010;
59 (void)memset_s(pinEnrollParam->salt, CONST_SALT_LEN, 1, CONST_SALT_LEN);
60 (void)memset_s(pinEnrollParam->pinData, CONST_PIN_DATA_LEN, 1, CONST_PIN_DATA_LEN);
61 uint64_t templateId = 0;
62 Buffer *outRootSecret = CreateBufferBySize(ROOT_SECRET_LEN);
63 uint32_t result = AddPin(pinEnrollParam, &templateId, outRootSecret);
64 EXPECT_EQ(result, RESULT_SUCCESS);
65 delete pinEnrollParam;
66
67 Buffer *pinData = CreateBufferBySize(CONST_PIN_DATA_LEN);
68 ASSERT_NE(pinData, nullptr);
69 (void)memset_s(pinData->buf, pinData->maxSize, 1, pinData->maxSize);
70 pinData->contentSize = pinData->maxSize;
71 ResultCode compareRet = RESULT_GENERAL_ERROR;
72 result = AuthPinById(pinData, 0, outRootSecret, &compareRet);
73 EXPECT_EQ(result, RESULT_BAD_MATCH);
74
75 result = AuthPinById(nullptr, 0, outRootSecret, &compareRet);
76 EXPECT_EQ(result, RESULT_BAD_PARAM);
77
78 pinData->contentSize = 0;
79 result = AuthPinById(pinData, templateId, outRootSecret, &compareRet);
80 EXPECT_EQ(result, RESULT_BAD_PARAM);
81 pinData->contentSize = pinData->maxSize;
82
83 result = AuthPinById(pinData, INVALID_TEMPLATE_ID, outRootSecret, &compareRet);
84 EXPECT_EQ(result, RESULT_BAD_PARAM);
85
86 result = AuthPinById(pinData, templateId, nullptr, &compareRet);
87 EXPECT_EQ(result, RESULT_SUCCESS);
88
89 result = AuthPinById(pinData, templateId, outRootSecret, nullptr);
90 EXPECT_EQ(result, RESULT_BAD_PARAM);
91
92 result = AuthPinById(pinData, templateId, outRootSecret, &compareRet);
93 EXPECT_EQ(result, RESULT_SUCCESS);
94 EXPECT_EQ(compareRet, RESULT_SUCCESS);
95
96 (void)memset_s(pinData->buf, pinData->maxSize, 2, pinData->maxSize);
97 result = AuthPinById(pinData, templateId, outRootSecret, &compareRet);
98 EXPECT_EQ(result, RESULT_SUCCESS);
99 EXPECT_EQ(compareRet, RESULT_COMPARE_FAIL);
100
101 result = DelPinById(templateId);
102 EXPECT_EQ(result, RESULT_SUCCESS);
103 DestroyBuffer(outRootSecret);
104 DestroyBuffer(pinData);
105 }
106
107 /**
108 * @tc.name: DoGetAlgoParameter test
109 * @tc.desc: verify DoGetAlgoParameter
110 * @tc.type: FUNC
111 * @tc.require: #I64XCB
112 */
113 HWTEST_F(PinDataBaseTest, DoGetAlgoParameter_test, TestSize.Level1)
114 {
115 PinEnrollParam *pinEnrollParam = new (std::nothrow) PinEnrollParam();
116 EXPECT_NE(pinEnrollParam, nullptr);
117
118 pinEnrollParam->scheduleId = 1;
119 pinEnrollParam->subType = 10010;
120 std::vector<uint8_t> salt(CONST_SALT_LEN, 1);
121 std::vector<uint8_t> pinData(CONST_PIN_DATA_LEN, 1);
122 (void)memcpy_s(&(pinEnrollParam->salt[0]), CONST_SALT_LEN, &salt[0], CONST_SALT_LEN);
123 (void)memcpy_s(&(pinEnrollParam->pinData[0]), CONST_PIN_DATA_LEN, &pinData[0], CONST_PIN_DATA_LEN);
124
125 uint64_t templateId = 0;
126 Buffer *outRootSecret = CreateBufferBySize(ROOT_SECRET_LEN);
127 EXPECT_NE(outRootSecret, nullptr);
128 uint32_t result = AddPin(pinEnrollParam, &templateId, outRootSecret);
129 EXPECT_EQ(result, RESULT_SUCCESS);
130 delete pinEnrollParam;
131 DestroyBuffer(outRootSecret);
132
133 uint32_t satLen = CONST_SALT_LEN;
134 std::vector<uint8_t> saltRes(CONST_SALT_LEN, 0);
135 uint32_t algoVersion;
136 result = DoGetAlgoParameter(INVALID_TEMPLATE_ID, &(saltRes[0]), &satLen, &algoVersion);
137 EXPECT_EQ(result, RESULT_BAD_PARAM);
138
139 result = DoGetAlgoParameter(templateId, nullptr, &satLen, &algoVersion);
140 EXPECT_EQ(result, RESULT_BAD_PARAM);
141
142 result = DoGetAlgoParameter(templateId, &(saltRes[0]), nullptr, &algoVersion);
143 EXPECT_EQ(result, RESULT_BAD_PARAM);
144
145 result = DoGetAlgoParameter(0, &(saltRes[0]), &satLen, &algoVersion);
146 EXPECT_EQ(result, RESULT_BAD_MATCH);
147
148 result = DoGetAlgoParameter(templateId, &(saltRes[0]), &satLen, &algoVersion);
149 EXPECT_EQ(algoVersion, 0);
150 EXPECT_EQ(result, RESULT_SUCCESS);
151
152 result = DelPinById(templateId);
153 EXPECT_EQ(result, RESULT_SUCCESS);
154 }
155
156 /**
157 * @tc.name: ComputeFreezeTime test
158 * @tc.desc: verify ComputeFreezeTime
159 * @tc.type: FUNC
160 * @tc.require: #I64XCB
161 */
162 HWTEST_F(PinDataBaseTest, ComputeFreezeTime_test, TestSize.Level1)
163 {
164 PinEnrollParam *pinEnrollParam = new (std::nothrow) PinEnrollParam();
165 EXPECT_NE(pinEnrollParam, nullptr);
166
167 pinEnrollParam->scheduleId = 1;
168 pinEnrollParam->subType = 10010;
169 std::vector<uint8_t> salt(CONST_SALT_LEN, 1);
170 std::vector<uint8_t> pinData(CONST_PIN_DATA_LEN, 1);
171 (void)memcpy_s(&(pinEnrollParam->salt[0]), CONST_SALT_LEN, &salt[0], CONST_SALT_LEN);
172 (void)memcpy_s(&(pinEnrollParam->pinData[0]), CONST_PIN_DATA_LEN, &pinData[0], CONST_PIN_DATA_LEN);
173
174 uint64_t templateId = 0;
175 Buffer *outRootSecret = CreateBufferBySize(ROOT_SECRET_LEN);
176 EXPECT_NE(outRootSecret, nullptr);
177 uint32_t result = AddPin(pinEnrollParam, &templateId, outRootSecret);
178 EXPECT_EQ(result, RESULT_SUCCESS);
179 delete pinEnrollParam;
180 DestroyBuffer(outRootSecret);
181
182 uint32_t freezeTime = 0;
183 result = ComputeFreezeTime(INVALID_TEMPLATE_ID, &freezeTime, 0, 0);
184 EXPECT_EQ(result, RESULT_BAD_PARAM);
185
186 result = ComputeFreezeTime(templateId, nullptr, 0, 0);
187 EXPECT_EQ(result, RESULT_BAD_PARAM);
188
189 result = ComputeFreezeTime(0, nullptr, 0, 0);
190 EXPECT_EQ(result, RESULT_BAD_PARAM);
191
192 result = ComputeFreezeTime(templateId, &freezeTime, 0, 0);
193 EXPECT_EQ(result, RESULT_SUCCESS);
194
195 result = DelPinById(templateId);
196 EXPECT_EQ(result, RESULT_SUCCESS);
197 }
198
199 /**
200 * @tc.name: GetRemainTimes test
201 * @tc.desc: verify GetRemainTimes
202 * @tc.type: FUNC
203 * @tc.require: #I64XCB
204 */
205 HWTEST_F(PinDataBaseTest, GetRemainTimes_test, TestSize.Level1)
206 {
207 PinEnrollParam *pinEnrollParam = new (std::nothrow) PinEnrollParam();
208 EXPECT_NE(pinEnrollParam, nullptr);
209
210 pinEnrollParam->scheduleId = 1;
211 pinEnrollParam->subType = 10010;
212 std::vector<uint8_t> salt(CONST_SALT_LEN, 1);
213 std::vector<uint8_t> pinData(CONST_PIN_DATA_LEN, 1);
214 (void)memcpy_s(&(pinEnrollParam->salt[0]), CONST_SALT_LEN, &salt[0], CONST_SALT_LEN);
215 (void)memcpy_s(&(pinEnrollParam->pinData[0]), CONST_PIN_DATA_LEN, &pinData[0], CONST_PIN_DATA_LEN);
216
217 uint64_t templateId = 0;
218 Buffer *outRootSecret = CreateBufferBySize(ROOT_SECRET_LEN);
219 EXPECT_NE(outRootSecret, nullptr);
220 uint32_t result = AddPin(pinEnrollParam, &templateId, outRootSecret);
221 EXPECT_EQ(result, RESULT_SUCCESS);
222 delete pinEnrollParam;
223 DestroyBuffer(outRootSecret);
224
225 uint32_t remainingAuthTimes = 0;
226 result = GetRemainTimes(INVALID_TEMPLATE_ID, &remainingAuthTimes, 0);
227 EXPECT_EQ(result, RESULT_BAD_PARAM);
228
229 result = GetRemainTimes(templateId, nullptr, 0);
230 EXPECT_EQ(result, RESULT_BAD_PARAM);
231
232 result = GetRemainTimes(templateId, &remainingAuthTimes, 0);
233 EXPECT_EQ(result, RESULT_SUCCESS);
234
235 result = DelPinById(templateId);
236 EXPECT_EQ(result, RESULT_SUCCESS);
237 }
238
239 /**
240 * @tc.name: GetSubType test
241 * @tc.desc: verify GetSubType
242 * @tc.type: FUNC
243 * @tc.require: #I64XCB
244 */
245 HWTEST_F(PinDataBaseTest, GetSubType_test, TestSize.Level1)
246 {
247 PinEnrollParam *pinEnrollParam = new (std::nothrow) PinEnrollParam();
248 EXPECT_NE(pinEnrollParam, nullptr);
249
250 pinEnrollParam->scheduleId = 1;
251 pinEnrollParam->subType = 10010;
252 std::vector<uint8_t> salt(CONST_SALT_LEN, 1);
253 std::vector<uint8_t> pinData(CONST_PIN_DATA_LEN, 1);
254 (void)memcpy_s(&(pinEnrollParam->salt[0]), CONST_SALT_LEN, &salt[0], CONST_SALT_LEN);
255 (void)memcpy_s(&(pinEnrollParam->pinData[0]), CONST_PIN_DATA_LEN, &pinData[0], CONST_PIN_DATA_LEN);
256
257 uint64_t templateId = 0;
258 Buffer *outRootSecret = CreateBufferBySize(ROOT_SECRET_LEN);
259 EXPECT_NE(outRootSecret, nullptr);
260 uint32_t result = AddPin(pinEnrollParam, &templateId, outRootSecret);
261 EXPECT_EQ(result, RESULT_SUCCESS);
262 delete pinEnrollParam;
263 DestroyBuffer(outRootSecret);
264
265 uint64_t subType = 0;
266 result = GetSubType(INVALID_TEMPLATE_ID, &subType);
267 EXPECT_EQ(result, RESULT_BAD_PARAM);
268
269 result = GetSubType(0, &subType);
270 EXPECT_EQ(result, RESULT_BAD_MATCH);
271
272 result = GetSubType(templateId, &subType);
273 EXPECT_EQ(result, RESULT_SUCCESS);
274
275 result = DelPinById(templateId);
276 EXPECT_EQ(result, RESULT_SUCCESS);
277 }
278
279 /**
280 * @tc.name: GetAntiBruteInfo test
281 * @tc.desc: verify GetAntiBruteInfo
282 * @tc.type: FUNC
283 * @tc.require: #I64XCB
284 */
285 HWTEST_F(PinDataBaseTest, GetAntiBruteInfo_test, TestSize.Level1)
286 {
287 PinEnrollParam *pinEnrollParam = new (std::nothrow) PinEnrollParam();
288 EXPECT_NE(pinEnrollParam, nullptr);
289
290 pinEnrollParam->scheduleId = 1;
291 pinEnrollParam->subType = 10010;
292 std::vector<uint8_t> salt(CONST_SALT_LEN, 1);
293 std::vector<uint8_t> pinData(CONST_PIN_DATA_LEN, 1);
294 (void)memcpy_s(&(pinEnrollParam->salt[0]), CONST_SALT_LEN, &salt[0], CONST_SALT_LEN);
295 (void)memcpy_s(&(pinEnrollParam->pinData[0]), CONST_PIN_DATA_LEN, &pinData[0], CONST_PIN_DATA_LEN);
296
297 uint64_t templateId = 0;
298 Buffer *outRootSecret = CreateBufferBySize(ROOT_SECRET_LEN);
299 EXPECT_NE(outRootSecret, nullptr);
300 uint32_t result = AddPin(pinEnrollParam, &templateId, outRootSecret);
301 EXPECT_EQ(result, RESULT_SUCCESS);
302 delete pinEnrollParam;
303 DestroyBuffer(outRootSecret);
304
305 uint32_t authErrorCount = 0;
306 uint64_t startFreezeTime = 0;
307 result = GetAntiBruteInfo(INVALID_TEMPLATE_ID, &authErrorCount, &startFreezeTime);
308 EXPECT_EQ(result, RESULT_BAD_PARAM);
309
310 result = GetAntiBruteInfo(templateId, nullptr, &startFreezeTime);
311 EXPECT_EQ(result, RESULT_BAD_PARAM);
312
313 result = GetAntiBruteInfo(templateId, &authErrorCount, nullptr);
314 EXPECT_EQ(result, RESULT_BAD_PARAM);
315
316 result = GetAntiBruteInfo(0, &authErrorCount, &startFreezeTime);
317 EXPECT_EQ(result, RESULT_BAD_MATCH);
318
319 result = GetAntiBruteInfo(templateId, &authErrorCount, &startFreezeTime);
320 EXPECT_EQ(result, RESULT_SUCCESS);
321
322 result = DelPinById(templateId);
323 EXPECT_EQ(result, RESULT_SUCCESS);
324 }
325
326 /**
327 * @tc.name: VerifyTemplateDataPin test
328 * @tc.desc: verify VerifyTemplateDataPin
329 * @tc.type: FUNC
330 * @tc.require: #I64XCB
331 */
332 HWTEST_F(PinDataBaseTest, VerifyTemplateDataPin_test, TestSize.Level1)
333 {
334 std::vector<uint64_t> templateIdList = {1, 0};
335 uint32_t templateIdListLen = 2;
336 uint32_t result = VerifyTemplateDataPin(&templateIdList[0], templateIdListLen);
337 EXPECT_EQ(result, RESULT_SUCCESS);
338
339 result = VerifyTemplateDataPin(nullptr, 1);
340 EXPECT_EQ(result, RESULT_BAD_PARAM);
341 }
342
343 /**
344 * @tc.name: GetNextFailLockoutDuration test
345 * @tc.desc: get next fail lockout duration
346 * @tc.type: FUNC
347 * @tc.require: #I64XCB
348 */
349 HWTEST_F(PinDataBaseTest, GetNextFailLockoutDuration_test, TestSize.Level1)
350 {
351 const uint32_t MS_OF_S = 1000uLL;
352 const uint32_t ONE_MIN_TIME = 60;
353 EXPECT_EQ(ONE_MIN_TIME * MS_OF_S, GetNextFailLockoutDuration(0));
354
355 const uint32_t FIRST_ANTI_BRUTE_COUNT = 5;
356 const uint32_t TEN_MIN_TIME = 600;
357 EXPECT_EQ(TEN_MIN_TIME * MS_OF_S, GetNextFailLockoutDuration(FIRST_ANTI_BRUTE_COUNT));
358
359 const uint32_t SECOND_ANTI_BRUTE_COUNT = 8;
360 const uint32_t THIRTY_MIN_TIME = 1800;
361 EXPECT_EQ(THIRTY_MIN_TIME * MS_OF_S, GetNextFailLockoutDuration(SECOND_ANTI_BRUTE_COUNT));
362
363 const uint32_t THIRD_ANTI_BRUTE_COUNT = 11;
364 const uint32_t ONE_HOUR_TIME = 3600;
365 EXPECT_EQ(ONE_HOUR_TIME * MS_OF_S, GetNextFailLockoutDuration(THIRD_ANTI_BRUTE_COUNT));
366
367 const uint32_t AUTH_ERROR_COUNT01 = 98;
368 const uint32_t FAIL_LOCKOUT_DURATION01 = 3840;
369 const uint32_t ATTI_BRUTE_FIRST_STAGE = 100;
370 EXPECT_EQ(FAIL_LOCKOUT_DURATION01 * MS_OF_S, GetNextFailLockoutDuration(AUTH_ERROR_COUNT01));
371 EXPECT_EQ(FAIL_LOCKOUT_DURATION01 * MS_OF_S, GetNextFailLockoutDuration(ATTI_BRUTE_FIRST_STAGE));
372
373 const uint32_t ATTI_BRUTE_SECOND_STAGE = 140;
374 const uint32_t ONE_DAY_TIME = 86400;
375 EXPECT_EQ(ONE_DAY_TIME * MS_OF_S, GetNextFailLockoutDuration(ATTI_BRUTE_SECOND_STAGE - 1));
376 }
377 } // namespace PinAuth
378 } // namespace UserIam
379 } // namespace OHOS
380