1 /*
2 * Copyright (c) 2025 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 #include <stdlib.h>
16 #include <stdio.h>
17 #include <pthread.h>
18 #include <string.h>
19 #include<math.h>
20
21 #include "crypto_framework_kdf_test.h"
22 #include "blob.h"
23 #include "log.h"
24
25 #include <gtest/gtest.h>
26
27 using namespace testing::ext;
28 namespace Unittest::CryptoFrameworkKdfNapiTest {
29 class OHCryptoFrameworkKdfNapiTest : public testing::Test {
30 public:
SetUpTestCase(void)31 static void SetUpTestCase(void) {};
TearDownTestCase(void)32 static void TearDownTestCase(void) {};
SetUp()33 void SetUp() {};
TearDown()34 void TearDown() {};
35 };
36
37 class KDF_TEST : public testing::TestWithParam<KdfSpec> {
38 public:
SetUpTestCase()39 static void SetUpTestCase() {};
TearDownTestCase()40 static void TearDownTestCase() {};
41 };
42
43 class KDF_SCRYPT_TEST : public testing::TestWithParam<KdfSpec> {
44 public:
SetUpTestCase()45 static void SetUpTestCase() {};
TearDownTestCase()46 static void TearDownTestCase() {};
47 };
48
49 class KDF_HKDF_TEST : public testing::TestWithParam<KdfSpec> {
50 public:
SetUpTestCase()51 static void SetUpTestCase() {};
TearDownTestCase()52 static void TearDownTestCase() {};
53 };
54
55 class KDF_PBKDF2_TEST : public testing::TestWithParam<KdfSpec> {
56 public:
SetUpTestCase()57 static void SetUpTestCase() {};
TearDownTestCase()58 static void TearDownTestCase() {};
59 };
60
61 class KDF_VECTOR_TEST : public testing::TestWithParam<KdfVectorSpec> {
62 public:
SetUpTestCase()63 static void SetUpTestCase() {};
TearDownTestCase()64 static void TearDownTestCase() {};
65 };
66
OHTEST_CreatePbkdf2Params(paramsSpec paramInfo,OH_CryptoKdfParams ** params)67 static OH_Crypto_ErrCode OHTEST_CreatePbkdf2Params(paramsSpec paramInfo, OH_CryptoKdfParams **params)
68 {
69 OH_Crypto_ErrCode ret = CRYPTO_SUCCESS;
70 Crypto_DataBlob password = {.data = paramInfo.pbkdf2Params.password, .len = 0};
71 Crypto_DataBlob salt = {.data = paramInfo.pbkdf2Params.salt, .len = 0};
72 Crypto_DataBlob iterations = {.data = (uint8_t *)&(paramInfo.pbkdf2Params.iterations), .len = sizeof(int)};
73
74 ret = OH_CryptoKdfParams_Create("PBKDF2", params);
75 if (ret != CRYPTO_SUCCESS) {
76 return ret;
77 }
78 if (paramInfo.pbkdf2Params.password) {
79 password.len = strlen((const char *)paramInfo.pbkdf2Params.password);
80 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_KEY_DATABLOB, &password);
81 if (ret != CRYPTO_SUCCESS) {
82 OH_CryptoKdfParams_Destroy(*params);
83 *params = nullptr;
84 return ret;
85 }
86 }
87 if (paramInfo.pbkdf2Params.salt) {
88 salt.len = strlen((const char *)paramInfo.pbkdf2Params.salt);
89 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_SALT_DATABLOB, &salt);
90 if (ret != CRYPTO_SUCCESS) {
91 OH_CryptoKdfParams_Destroy(*params);
92 *params = nullptr;
93 return ret;
94 }
95 }
96 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_ITER_COUNT_INT, &iterations);
97 if (ret != CRYPTO_SUCCESS) {
98 OH_CryptoKdfParams_Destroy(*params);
99 *params = nullptr;
100 return ret;
101 }
102
103 return ret;
104 }
105
OHTEST_CreateHkdfParams(paramsSpec paramInfo,OH_CryptoKdfParams ** params)106 static OH_Crypto_ErrCode OHTEST_CreateHkdfParams(paramsSpec paramInfo, OH_CryptoKdfParams **params)
107 {
108 OH_Crypto_ErrCode ret = CRYPTO_SUCCESS;
109 Crypto_DataBlob key = {.data = paramInfo.hkdfParams.key, .len = 0};
110 Crypto_DataBlob salt = {.data = paramInfo.hkdfParams.salt, .len = 0};
111 Crypto_DataBlob info = {.data = paramInfo.hkdfParams.info, .len = 0};
112
113 ret = OH_CryptoKdfParams_Create("HKDF", params);
114 if (ret != CRYPTO_SUCCESS) {
115 return ret;
116 }
117 if (paramInfo.hkdfParams.key) {
118 key.len = strlen((const char *)paramInfo.hkdfParams.key);
119 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_KEY_DATABLOB, &key);
120 if (ret != CRYPTO_SUCCESS) {
121 OH_CryptoKdfParams_Destroy(*params);
122 *params = nullptr;
123 return ret;
124 }
125 }
126 if (paramInfo.hkdfParams.salt) {
127 salt.len = strlen((const char *)paramInfo.hkdfParams.salt);
128 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_SALT_DATABLOB, &salt);
129 if (ret != CRYPTO_SUCCESS) {
130 OH_CryptoKdfParams_Destroy(*params);
131 *params = nullptr;
132 return ret;
133 }
134 }
135 if (paramInfo.hkdfParams.info) {
136 info.len = strlen((const char *)paramInfo.hkdfParams.info);
137 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_INFO_DATABLOB, &info);
138 if (ret != CRYPTO_SUCCESS) {
139 OH_CryptoKdfParams_Destroy(*params);
140 *params = nullptr;
141 return ret;
142 }
143 }
144
145 return ret;
146 }
147
OHTEST_CreateScryptParams(paramsSpec paramInfo,OH_CryptoKdfParams ** params)148 static OH_Crypto_ErrCode OHTEST_CreateScryptParams(paramsSpec paramInfo, OH_CryptoKdfParams **params)
149 {
150 OH_Crypto_ErrCode ret = CRYPTO_SUCCESS;
151 Crypto_DataBlob passphrase = {.data = paramInfo.scryptParams.passphrase, .len = 0};
152 Crypto_DataBlob salt = {.data = paramInfo.scryptParams.salt, .len = 0};
153 Crypto_DataBlob n = {.data = (uint8_t *)&(paramInfo.scryptParams.n), .len = sizeof(uint64_t)};
154 Crypto_DataBlob p = {.data = (uint8_t *)&(paramInfo.scryptParams.p), .len = sizeof(uint64_t)};
155 Crypto_DataBlob r = {.data = (uint8_t *)&(paramInfo.scryptParams.r), .len = sizeof(uint64_t)};
156 Crypto_DataBlob max_mem = {.data = (uint8_t *)&(paramInfo.scryptParams.max_mem), .len = sizeof(uint64_t)};
157
158 ret = OH_CryptoKdfParams_Create("SCRYPT", params);
159 if (ret != CRYPTO_SUCCESS) {
160 return ret;
161 }
162 if (paramInfo.scryptParams.passphrase) {
163 passphrase.len = strlen((const char *)paramInfo.scryptParams.passphrase);
164 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_KEY_DATABLOB, &passphrase);
165 if (ret != CRYPTO_SUCCESS) {
166 OH_CryptoKdfParams_Destroy(*params);
167 *params = nullptr;
168 return ret;
169 }
170 }
171 if (paramInfo.scryptParams.salt) {
172 salt.len = strlen((const char *)paramInfo.scryptParams.salt);
173 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_SALT_DATABLOB, &salt);
174 if (ret != CRYPTO_SUCCESS) {
175 OH_CryptoKdfParams_Destroy(*params);
176 *params = nullptr;
177 return ret;
178 }
179 }
180 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_SCRYPT_N_UINT64, &n);
181 if (ret != CRYPTO_SUCCESS) {
182 OH_CryptoKdfParams_Destroy(*params);
183 *params = nullptr;
184 return ret;
185 }
186 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_SCRYPT_P_UINT64, &p);
187 if (ret != CRYPTO_SUCCESS) {
188 OH_CryptoKdfParams_Destroy(*params);
189 *params = nullptr;
190 return ret;
191 }
192 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_SCRYPT_R_UINT64, &r);
193 if (ret != CRYPTO_SUCCESS) {
194 OH_CryptoKdfParams_Destroy(*params);
195 *params = nullptr;
196 return ret;
197 }
198 if (*(uint64_t *)&(paramInfo.scryptParams.max_mem)) {
199 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_SCRYPT_MAX_MEM_UINT64, &max_mem);
200 if (ret != CRYPTO_SUCCESS) {
201 OH_CryptoKdfParams_Destroy(*params);
202 *params = nullptr;
203 return ret;
204 }
205 }
206
207 return ret;
208 }
209
210 KdfSpec g_kdfSpec[] = {
211 /* PBKDF2 */
212 {
213 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA1", .keySize = 64,
214 .params.pbkdf2Params = {.password = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .iterations = 16}
215 }, // 0
216 {
217 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA224", .keySize = 64,
218 .params.pbkdf2Params = {.password = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .iterations = 16}
219 },
220 {
221 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA256", .keySize = 64,
222 .params.pbkdf2Params = {.password = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .iterations = 16}
223 },
224 {
225 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA384", .keySize = 64,
226 .params.pbkdf2Params = {.password = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .iterations = 16}
227 },
228 {
229 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA512", .keySize = 64,
230 .params.pbkdf2Params = {.password = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .iterations = 16}
231 },
232 {
233 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SM3", .keySize = 64,
234 .params.pbkdf2Params = {.password = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .iterations = 16}
235 },
236 /* HKDF */
237 {
238 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1|EXPAND_ONLY", .keySize = OHTEST_SHA1_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
239 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
240 }, // 6
241 {
242 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1|EXTRACT_ONLY", .keySize = OHTEST_SHA1_DIGIESTSIZE,
243 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
244 },
245 {
246 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1|EXTRACT_AND_EXPAND", .keySize = OHTEST_SHA1_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
247 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
248 },
249 {
250 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA224|EXPAND_ONLY", .keySize = OHTEST_SHA224_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
251 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
252 },
253 {
254 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA224|EXTRACT_ONLY", .keySize = OHTEST_SHA224_DIGIESTSIZE,
255 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
256 },
257 {
258 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA224|EXTRACT_AND_EXPAND", .keySize = OHTEST_SHA224_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
259 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
260 },
261 {
262 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA256|EXPAND_ONLY", .keySize = OHTEST_SHA256_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
263 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
264 },
265 {
266 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA256|EXTRACT_ONLY", .keySize = OHTEST_SHA256_DIGIESTSIZE,
267 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
268 },
269 {
270 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA256|EXTRACT_AND_EXPAND", .keySize = OHTEST_SHA256_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
271 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
272 },
273 {
274 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA384|EXPAND_ONLY", .keySize = OHTEST_SHA384_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
275 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
276 },
277 {
278 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA384|EXTRACT_ONLY", .keySize = OHTEST_SHA384_DIGIESTSIZE,
279 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
280 },
281 {
282 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA384|EXTRACT_AND_EXPAND", .keySize = OHTEST_SHA384_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
283 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
284 },
285 {
286 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA512|EXPAND_ONLY", .keySize = OHTEST_SHA512_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
287 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
288 },
289 {
290 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA512|EXTRACT_ONLY", .keySize = OHTEST_SHA512_DIGIESTSIZE,
291 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
292 },
293 {
294 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA512|EXTRACT_AND_EXPAND", .keySize = OHTEST_SHA512_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
295 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
296 },
297 {
298 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SM3|EXPAND_ONLY", .keySize = OHTEST_SM3_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
299 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
300 },
301 {
302 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SM3|EXTRACT_ONLY", .keySize = OHTEST_SM3_DIGIESTSIZE,
303 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
304 },
305 {
306 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SM3|EXTRACT_AND_EXPAND", .keySize = OHTEST_SM3_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
307 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
308 },
309 {
310 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|MD5|EXPAND_ONLY", .keySize = OHTEST_MD5_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
311 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
312 },
313 {
314 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|MD5|EXTRACT_ONLY", .keySize = OHTEST_MD5_DIGIESTSIZE,
315 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
316 },
317 {
318 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|MD5|EXTRACT_AND_EXPAND", .keySize = OHTEST_MD5_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
319 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
320 },
321 {
322 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|MD5", .keySize = OHTEST_MD5_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
323 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
324 },
325 /* SCRYPT */
326 {
327 .kdfType = OHTEST_KDF_SCRYPT, .algoName = "SCRYPT", .keySize = 64,
328 // max_mem = p * 128 * r + 32 * r * (n + 2) * 4 + 1
329 .params.scryptParams = {.passphrase = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .n = 1024, .p = 1, .r = 8, .max_mem = 1051649}
330 }, // 28
331 };
332 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkKdfNapiTest, KDF_TEST, ::testing::ValuesIn(g_kdfSpec));
333
334 /**
335 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_0100
336 * @tc.name OHCryptoFrameworkKdfNapiTest/KDF_TEST.SUB_Security_CryptoFramework_NAPI_Kdf_Test_0100/x
337 * @tc.desc algorithm is Kdf
338 * @tc.size Medium
339 * @tc.type Func
340 * @tc.level Level0
341 */
342 HWTEST_P(KDF_TEST, SUB_Security_CryptoFramework_NAPI_Kdf_Test_0100, TestSize.Level0)
343 {
344 KdfSpec infoSpec = GetParam();
345 KdfType kdfType = infoSpec.kdfType;
346 const char *algoName = infoSpec.algoName;
347 int keySize = infoSpec.keySize;
348 OH_CryptoKdfParams *params = nullptr;
349 OH_CryptoKdf *ctx = nullptr;
350 Crypto_DataBlob key = {.data = nullptr, .len = 0};
351
352 switch(kdfType) {
353 case OHTEST_KDF_PBKDF2:
354 EXPECT_EQ(OHTEST_CreatePbkdf2Params(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
355 break;
356 case OHTEST_KDF_HKDF:
357 EXPECT_EQ(OHTEST_CreateHkdfParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
358 break;
359 case OHTEST_KDF_SCRYPT:
360 EXPECT_EQ(OHTEST_CreateScryptParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
361 break;
362 default:
363 break;
364 }
365 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
366 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_SUCCESS);
367 EXPECT_EQ(key.len, keySize);
368
369 OH_CryptoKdfParams_Destroy(params);
370 OH_CryptoKdf_Destroy(ctx);
371 OH_Crypto_FreeDataBlob(&key);
372 }
373
374 /**
375 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_0200
376 * @tc.name OHCryptoFrameworkKdfNapiTest.SUB_Security_CryptoFramework_NAPI_Kdf_Test_0200
377 * @tc.desc algorithm is Kdf
378 * @tc.size Medium
379 * @tc.type Func
380 * @tc.level Level0
381 */
382 HWTEST_F(OHCryptoFrameworkKdfNapiTest, SUB_Security_CryptoFramework_NAPI_Kdf_Test_0200, TestSize.Level0)
383 {
384 KdfSpec infoSpec = {
385 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SM3|EXPAND_ONLY", .keySize = OHTEST_SM3_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
386 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
387 };
388 const char *algoName = "SCRYPT";
389 int keySize = infoSpec.keySize;
390 OH_CryptoKdfParams *params = nullptr;
391 OH_CryptoKdf *ctx = nullptr;
392 Crypto_DataBlob key = {.data = nullptr, .len = 0};
393
394 EXPECT_EQ(OHTEST_CreateHkdfParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
395 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
396 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_PARAMETER_CHECK_FAILED);
397
398 OH_CryptoKdfParams_Destroy(params);
399 OH_CryptoKdf_Destroy(ctx);
400 OH_Crypto_FreeDataBlob(&key);
401 }
402
403 /**
404 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_0300
405 * @tc.name OHCryptoFrameworkKdfNapiTest.SUB_Security_CryptoFramework_NAPI_Kdf_Test_0300
406 * @tc.desc algorithm is Kdf
407 * @tc.size Medium
408 * @tc.type Func
409 * @tc.level Level0
410 */
411 HWTEST_F(OHCryptoFrameworkKdfNapiTest, SUB_Security_CryptoFramework_NAPI_Kdf_Test_0300, TestSize.Level0)
412 {
413 KdfSpec infoSpec = {
414 .kdfType = OHTEST_KDF_SCRYPT, .algoName = "SCRYPT", .keySize = 64,
415 // max_mem = p * 128 * r + 32 * r * (n + 2) * 4 + 1
416 .params.scryptParams = {.passphrase = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .n = 1024, .p = 1, .r = 8, .max_mem = 1051649}
417 };
418 const char *algoName = "HKDF|SHA1|EXPAND_ONLY";
419 int keySize = infoSpec.keySize;
420 OH_CryptoKdfParams *params = nullptr;
421 OH_CryptoKdf *ctx = nullptr;
422 Crypto_DataBlob key = {.data = nullptr, .len = 0};
423
424 EXPECT_EQ(OHTEST_CreateScryptParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
425 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
426 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_PARAMETER_CHECK_FAILED);
427
428 OH_CryptoKdfParams_Destroy(params);
429 OH_CryptoKdf_Destroy(ctx);
430 OH_Crypto_FreeDataBlob(&key);
431 }
432
433 /**
434 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_0400
435 * @tc.name OHCryptoFrameworkKdfNapiTest.SUB_Security_CryptoFramework_NAPI_Kdf_Test_0400
436 * @tc.desc algorithm is Kdf
437 * @tc.size Medium
438 * @tc.type Func
439 * @tc.level Level0
440 */
441 HWTEST_F(OHCryptoFrameworkKdfNapiTest, SUB_Security_CryptoFramework_NAPI_Kdf_Test_0400, TestSize.Level0)
442 {
443 KdfSpec infoSpec = {
444 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|MD5|EXTRACT_ONLY", .keySize = OHTEST_MD5_DIGIESTSIZE,
445 .params.hkdfParams = {.key = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .info = (uint8_t *)"abc"}
446 };
447 const char *algoName = "PBKDF2|SHA1";
448 int keySize = infoSpec.keySize;
449 OH_CryptoKdfParams *params = nullptr;
450 OH_CryptoKdf *ctx = nullptr;
451 Crypto_DataBlob key = {.data = nullptr, .len = 0};
452
453 EXPECT_EQ(OHTEST_CreateHkdfParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
454 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
455 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_PARAMETER_CHECK_FAILED);
456
457 OH_CryptoKdfParams_Destroy(params);
458 OH_CryptoKdf_Destroy(ctx);
459 OH_Crypto_FreeDataBlob(&key);
460 }
461
462 /**
463 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_0500
464 * @tc.name OHCryptoFrameworkKdfNapiTest.SUB_Security_CryptoFramework_NAPI_Kdf_Test_0500
465 * @tc.desc algorithm is Kdf
466 * @tc.size Medium
467 * @tc.type Func
468 * @tc.level Level0
469 */
470 HWTEST_F(OHCryptoFrameworkKdfNapiTest, SUB_Security_CryptoFramework_NAPI_Kdf_Test_0500, TestSize.Level0)
471 {
472 KdfSpec infoSpec = {
473 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA1", .keySize = 64,
474 .params.pbkdf2Params = {.password = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .iterations = 16}
475 };
476 const char *algoName = "HKDF|MD5|EXTRACT_ONLY";
477 int keySize = infoSpec.keySize;
478 OH_CryptoKdfParams *params = nullptr;
479 OH_CryptoKdf *ctx = nullptr;
480 Crypto_DataBlob key = {.data = nullptr, .len = 0};
481
482 EXPECT_EQ(OHTEST_CreatePbkdf2Params(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
483 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
484 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_PARAMETER_CHECK_FAILED);
485
486 OH_CryptoKdfParams_Destroy(params);
487 OH_CryptoKdf_Destroy(ctx);
488 OH_Crypto_FreeDataBlob(&key);
489 }
490
491 KdfSpec g_scryptErrorSpec[] = {
492 /* RFC7914 */
493 {
494 .kdfType = OHTEST_KDF_SCRYPT, .algoName = "SCRYPT", .keySize = 64,
495 /* N > 2^(128 * r / 8) */
496 .params.scryptParams = {
497 .passphrase = (uint8_t *)"0123456789",
498 .salt = (uint8_t *)"abcdef",
499 .n = pow(2, 16),
500 .p = 1,
501 .r = 1,
502 .max_mem = 0
503 }
504 },
505 {
506 .kdfType = OHTEST_KDF_SCRYPT, .algoName = "SCRYPT", .keySize = 64,
507 /* p > ((2^32 - 1) * 32) / (128 * r) */
508 .params.scryptParams = {
509 .passphrase = (uint8_t *)"0123456789",
510 .salt = (uint8_t *)"abcdef",
511 .n = 1024,
512 .p = pow(2, 16),
513 .r = pow(2, 16),
514 .max_mem = 0
515 }
516 },
517 {
518 .kdfType = OHTEST_KDF_SCRYPT, .algoName = "SCRYPT", .keySize = 64,
519 /* r * p > 2^30 - 1 */
520 .params.scryptParams = {
521 .passphrase = (uint8_t *)"0123456789",
522 .salt = (uint8_t *)"abcdef",
523 .n = 1024,
524 .p = pow(2, 14),
525 .r = pow(2, 16),
526 .max_mem = 0
527 }
528 },
529 {
530 .kdfType = OHTEST_KDF_SCRYPT, .algoName = "SCRYPT", .keySize = 64,
531 /* p * 128 * r > UINT32_MAX */
532 .params.scryptParams = {
533 .passphrase = (uint8_t *)"0123456789",
534 .salt = (uint8_t *)"abcdef",
535 .n = 1024,
536 .p = pow(2, 14),
537 .r = pow(2, 16),
538 .max_mem = 0
539 }
540 },
541 {
542 .kdfType = OHTEST_KDF_SCRYPT, .algoName = "SCRYPT", .keySize = 64,
543 /* n != 2^x */
544 .params.scryptParams = {
545 .passphrase = (uint8_t *)"0123456789",
546 .salt = (uint8_t *)"abcdef",
547 .n = 7,
548 .p = 1,
549 .r = 8,
550 .max_mem = 0
551 }
552 },
553 };
554 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkKdfNapiTest, KDF_SCRYPT_TEST, ::testing::ValuesIn(g_scryptErrorSpec));
555
556 /**
557 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_0600
558 * @tc.name OHCryptoFrameworkKdfNapiTest/KDF_SCRYPT_TEST.SUB_Security_CryptoFramework_NAPI_Kdf_Test_0600
559 * @tc.desc algorithm is Kdf
560 * @tc.size Medium
561 * @tc.type Func
562 * @tc.level Level0
563 */
564 HWTEST_P(KDF_SCRYPT_TEST, SUB_Security_CryptoFramework_NAPI_Kdf_Test_0600, TestSize.Level0)
565 {
566 KdfSpec infoSpec = GetParam();
567 const char *algoName = infoSpec.algoName;
568 int keySize = infoSpec.keySize;
569 OH_CryptoKdfParams *params = nullptr;
570 OH_CryptoKdf *ctx = nullptr;
571 Crypto_DataBlob key = {.data = nullptr, .len = 0};
572 uint64_t p = *(uint64_t *)&(infoSpec.params.scryptParams.p);
573 uint64_t n = *(uint64_t *)&(infoSpec.params.scryptParams.n);
574 uint64_t r = *(uint64_t *)&(infoSpec.params.scryptParams.r);
575 /* p * 128 * r + 32 * r * (n + 2) * 4 + 1 */
576 uint64_t max_mem = p * 128 * r + 32 * r * (n + 2) * 4 + 1;
577
578 infoSpec.params.scryptParams.max_mem = max_mem;
579 EXPECT_EQ(OHTEST_CreateScryptParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
580 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
581 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_OPERTION_ERROR);
582
583 OH_CryptoKdfParams_Destroy(params);
584 OH_CryptoKdf_Destroy(ctx);
585 OH_Crypto_FreeDataBlob(&key);
586 }
587
588 /**
589 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_0700
590 * @tc.name OHCryptoFrameworkKdfNapiTest.SUB_Security_CryptoFramework_NAPI_Kdf_Test_0700
591 * @tc.desc algorithm is Kdf
592 * @tc.size Medium
593 * @tc.type Func
594 * @tc.level Level0
595 */
596 HWTEST_F(OHCryptoFrameworkKdfNapiTest, SUB_Security_CryptoFramework_NAPI_Kdf_Test_0700, TestSize.Level0)
597 {
598 KdfSpec infoSpec = {
599 .kdfType = OHTEST_KDF_SCRYPT, .algoName = "SCRYPT", .keySize = 64,
600 /* max_mem < p * 128 * r + 32 * r * (n + 2) * 4 */
601 .params.scryptParams = {
602 .passphrase = (uint8_t *)"0123456789",
603 .salt = (uint8_t *)"abcdef",
604 .n = 1024,
605 .p = 1,
606 .r = 8,
607 .max_mem = 0
608 }
609 };
610 const char *algoName = infoSpec.algoName;
611 int keySize = infoSpec.keySize;
612 OH_CryptoKdfParams *params = nullptr;
613 OH_CryptoKdf *ctx = nullptr;
614 Crypto_DataBlob key = {.data = nullptr, .len = 0};
615 uint64_t p = *(uint64_t *)&(infoSpec.params.scryptParams.p);
616 uint64_t n = *(uint64_t *)&(infoSpec.params.scryptParams.n);
617 uint64_t r = *(uint64_t *)&(infoSpec.params.scryptParams.r);
618 /* p * 128 * r + 32 * r * (n + 2) * 4 - 1 */
619 uint64_t max_mem = p * 128 * r + 32 * r * (n + 2) * 4 - 1;
620
621 infoSpec.params.scryptParams.max_mem = max_mem;
622 EXPECT_EQ(OHTEST_CreateScryptParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
623 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
624 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_OPERTION_ERROR);
625
626 OH_CryptoKdfParams_Destroy(params);
627 OH_CryptoKdf_Destroy(ctx);
628 OH_Crypto_FreeDataBlob(&key);
629 }
630
631 /**
632 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_0800
633 * @tc.name OHCryptoFrameworkKdfNapiTest.SUB_Security_CryptoFramework_NAPI_Kdf_Test_0800
634 * @tc.desc algorithm is Kdf
635 * @tc.size Medium
636 * @tc.type Func
637 * @tc.level Level0
638 */
639 HWTEST_F(OHCryptoFrameworkKdfNapiTest, SUB_Security_CryptoFramework_NAPI_Kdf_Test_0800, TestSize.Level0)
640 {
641 KdfSpec infoSpec = {
642 .kdfType = OHTEST_KDF_SCRYPT, .algoName = "SCRYPT", .keySize = 64,
643 /* max_mem < p * 128 * r + 32 * r * (n + 2) * 4 */
644 .params.scryptParams = {
645 .passphrase = nullptr,
646 .salt = (uint8_t *)"abcdef",
647 .n = 1024,
648 .p = 1,
649 .r = 8,
650 .max_mem = 1051649
651 }
652 };
653 const char *algoName = infoSpec.algoName;
654 int keySize = infoSpec.keySize;
655 OH_CryptoKdfParams *params = nullptr;
656 OH_CryptoKdf *ctx = nullptr;
657 Crypto_DataBlob key = {.data = nullptr, .len = 0};
658
659 EXPECT_EQ(OHTEST_CreateScryptParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
660 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
661 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_PARAMETER_CHECK_FAILED);
662
663 OH_CryptoKdfParams_Destroy(params);
664 OH_CryptoKdf_Destroy(ctx);
665 OH_Crypto_FreeDataBlob(&key);
666 }
667
668 /**
669 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_0900
670 * @tc.name OHCryptoFrameworkKdfNapiTest.SUB_Security_CryptoFramework_NAPI_Kdf_Test_0900
671 * @tc.desc algorithm is Kdf
672 * @tc.size Medium
673 * @tc.type Func
674 * @tc.level Level0
675 */
676 HWTEST_F(OHCryptoFrameworkKdfNapiTest, SUB_Security_CryptoFramework_NAPI_Kdf_Test_0900, TestSize.Level0)
677 {
678 KdfSpec infoSpec = {
679 .kdfType = OHTEST_KDF_SCRYPT, .algoName = "SCRYPT", .keySize = 64,
680 /* max_mem < p * 128 * r + 32 * r * (n + 2) * 4 */
681 .params.scryptParams = {
682 .passphrase = (uint8_t *)"0123456789",
683 .salt = nullptr,
684 .n = 1024,
685 .p = 1,
686 .r = 8,
687 .max_mem = 1051649
688 }
689 };
690 const char *algoName = infoSpec.algoName;
691 int keySize = infoSpec.keySize;
692 OH_CryptoKdfParams *params = nullptr;
693 OH_CryptoKdf *ctx = nullptr;
694 Crypto_DataBlob key = {.data = nullptr, .len = 0};
695
696 EXPECT_EQ(OHTEST_CreateScryptParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
697 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
698 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_SUCCESS);
699
700 OH_CryptoKdfParams_Destroy(params);
701 OH_CryptoKdf_Destroy(ctx);
702 OH_Crypto_FreeDataBlob(&key);
703 }
704
705 KdfSpec g_hkdfErrorSpec[] = {
706 {
707 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1|EXPAND_ONLY", .keySize = OHTEST_SHA1_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
708 .params.hkdfParams = {
709 .key = (uint8_t *)"0123456789",
710 .salt = nullptr,
711 .info = (uint8_t *)"abc"
712 }
713 },
714 {
715 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1|EXPAND_ONLY", .keySize = OHTEST_SHA1_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
716 .params.hkdfParams = {
717 .key = nullptr,
718 .salt = (uint8_t *)"abcdef",
719 .info = (uint8_t *)"abc"
720 }
721 },
722 {
723 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1|EXPAND_ONLY", .keySize = OHTEST_SHA1_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN - 1,
724 .params.hkdfParams = {
725 .key = (uint8_t *)"0123456789",
726 .salt = (uint8_t *)"abcdef",
727 .info = nullptr
728 }
729 },
730 {
731 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1|EXPAND_ONLY", .keySize = OHTEST_SHA1_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN + 1,
732 .params.hkdfParams = {
733 .key = (uint8_t *)"0123456789",
734 .salt = (uint8_t *)"abcdef",
735 .info = (uint8_t *)"abc"
736 }
737 },
738 {
739 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1|EXTRACT_ONLY", .keySize = OHTEST_SHA1_DIGIESTSIZE + 1,
740 .params.hkdfParams = {
741 .key = (uint8_t *)"0123456789",
742 .salt = (uint8_t *)"abcdef",
743 .info = (uint8_t *)"abc"
744 }
745 },
746 {
747 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1|EXTRACT_ONLY", .keySize = OHTEST_SHA1_DIGIESTSIZE - 1,
748 .params.hkdfParams = {
749 .key = (uint8_t *)"0123456789",
750 .salt = (uint8_t *)"abcdef",
751 .info = (uint8_t *)"abc"
752 }
753 },
754 {
755 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1|EXTRACT_AND_EXPAND", .keySize = OHTEST_SHA1_DIGIESTSIZE * OHTEST_KDF_CONSTANT_LEN + 1,
756 .params.hkdfParams = {
757 .key = (uint8_t *)"0123456789",
758 .salt = (uint8_t *)"abcdef",
759 .info = (uint8_t *)"abc"
760 }
761 },
762 };
763 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkKdfNapiTest, KDF_HKDF_TEST, ::testing::ValuesIn(g_hkdfErrorSpec));
764
765 /**
766 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_1000
767 * @tc.name OHCryptoFrameworkKdfNapiTest/KDF_HKDF_TEST.SUB_Security_CryptoFramework_NAPI_Kdf_Test_1000
768 * @tc.desc algorithm is Kdf
769 * @tc.size Medium
770 * @tc.type Func
771 * @tc.level Level0
772 */
773 HWTEST_P(KDF_HKDF_TEST, SUB_Security_CryptoFramework_NAPI_Kdf_Test_1000, TestSize.Level0)
774 {
775 KdfSpec infoSpec = GetParam();
776 const char *algoName = infoSpec.algoName;
777 int keySize = infoSpec.keySize;
778 OH_CryptoKdfParams *params = nullptr;
779 OH_CryptoKdf *ctx = nullptr;
780 Crypto_DataBlob key = {.data = nullptr, .len = 0};
781
782 EXPECT_EQ(OHTEST_CreateHkdfParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
783 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
784 if (infoSpec.params.hkdfParams.key && infoSpec.params.hkdfParams.salt && infoSpec.params.hkdfParams.info) {
785 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_OPERTION_ERROR);
786 } else if (infoSpec.params.hkdfParams.key) {
787 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_SUCCESS);
788 } else {
789 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_PARAMETER_CHECK_FAILED);
790 }
791
792 OH_CryptoKdfParams_Destroy(params);
793 OH_CryptoKdf_Destroy(ctx);
794 OH_Crypto_FreeDataBlob(&key);
795 }
796
797 KdfSpec g_pbkdf2ErrorSpec[] = {
798 {
799 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA1", .keySize = 64,
800 .params.pbkdf2Params = {.password = nullptr, .salt = (uint8_t *)"abcdef", .iterations = 16}
801 },
802 {
803 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA1", .keySize = 64,
804 .params.pbkdf2Params = {.password = (uint8_t *)"0123456789", .salt = nullptr, .iterations = 16}
805 },
806 {
807 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA1", .keySize = 64,
808 .params.pbkdf2Params = {.password = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .iterations = 0}
809 },
810 {
811 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA1", .keySize = -1,
812 .params.pbkdf2Params = {.password = (uint8_t *)"0123456789", .salt = (uint8_t *)"abcdef", .iterations = 16}
813 }
814 };
815 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkKdfNapiTest, KDF_PBKDF2_TEST, ::testing::ValuesIn(g_pbkdf2ErrorSpec));
816
817 /**
818 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_1100
819 * @tc.name OHCryptoFrameworkKdfNapiTest/KDF_PBKDF2_TEST.SUB_Security_CryptoFramework_NAPI_Kdf_Test_1100/x
820 * @tc.desc algorithm is Kdf
821 * @tc.size Medium
822 * @tc.type Func
823 * @tc.level Level0
824 */
825 HWTEST_P(KDF_PBKDF2_TEST, SUB_Security_CryptoFramework_NAPI_Kdf_Test_1100, TestSize.Level0)
826 {
827 KdfSpec infoSpec = GetParam();
828 const char *algoName = infoSpec.algoName;
829 int keySize = infoSpec.keySize;
830 OH_CryptoKdfParams *params = nullptr;
831 OH_CryptoKdf *ctx = nullptr;
832 Crypto_DataBlob key = {.data = nullptr, .len = 0};
833
834 EXPECT_EQ(OHTEST_CreatePbkdf2Params(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
835 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
836 if (infoSpec.keySize < 0) {
837 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_PARAMETER_CHECK_FAILED);
838 } else if (*(int *)&(infoSpec.params.pbkdf2Params.iterations)) {
839 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_SUCCESS);
840 } else {
841 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_PARAMETER_CHECK_FAILED);
842 }
843
844 OH_CryptoKdfParams_Destroy(params);
845 OH_CryptoKdf_Destroy(ctx);
846 OH_Crypto_FreeDataBlob(&key);
847 }
848
849 /**
850 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Test_1200
851 * @tc.name OHCryptoFrameworkKdfNapiTest.SUB_Security_CryptoFramework_NAPI_Kdf_Test_1200
852 * @tc.desc algorithm is Kdf
853 * @tc.size Medium
854 * @tc.type Func
855 * @tc.level Level0
856 */
857 HWTEST_F(OHCryptoFrameworkKdfNapiTest, SUB_Security_CryptoFramework_NAPI_Kdf_Test_1200, TestSize.Level0)
858 {
859 const char *algoName = "KDF_TLS12";
860 OH_CryptoKdfParams *params = nullptr;
861 OH_CryptoKdf *ctx = nullptr;
862
863 EXPECT_EQ(OH_CryptoKdfParams_Create(algoName, ¶ms), CRYPTO_PARAMETER_CHECK_FAILED);
864 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_PARAMETER_CHECK_FAILED);
865
866 OH_CryptoKdfParams_Destroy(params);
867 OH_CryptoKdf_Destroy(ctx);
868 }
869
OHTEST_CreateVectorPbkdf2Params(paramsVectorSpec paramInfo,OH_CryptoKdfParams ** params)870 static OH_Crypto_ErrCode OHTEST_CreateVectorPbkdf2Params(paramsVectorSpec paramInfo, OH_CryptoKdfParams **params)
871 {
872 OH_Crypto_ErrCode ret = CRYPTO_SUCCESS;
873 Crypto_DataBlob password = {.data = paramInfo.pbkdf2Params.password, .len = paramInfo.pbkdf2Params.passLen};
874 Crypto_DataBlob salt = {.data = paramInfo.pbkdf2Params.salt, .len = paramInfo.pbkdf2Params.saltLen};
875 Crypto_DataBlob iterations = {.data = (uint8_t *)&(paramInfo.pbkdf2Params.iterations), .len = sizeof(int)};
876
877 ret = OH_CryptoKdfParams_Create("PBKDF2", params);
878 if (ret != CRYPTO_SUCCESS) {
879 return ret;
880 }
881 if (paramInfo.pbkdf2Params.password) {
882 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_KEY_DATABLOB, &password);
883 if (ret != CRYPTO_SUCCESS) {
884 OH_CryptoKdfParams_Destroy(*params);
885 *params = nullptr;
886 return ret;
887 }
888 }
889 if (paramInfo.pbkdf2Params.salt) {
890 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_SALT_DATABLOB, &salt);
891 if (ret != CRYPTO_SUCCESS) {
892 OH_CryptoKdfParams_Destroy(*params);
893 *params = nullptr;
894 return ret;
895 }
896 }
897 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_ITER_COUNT_INT, &iterations);
898 if (ret != CRYPTO_SUCCESS) {
899 OH_CryptoKdfParams_Destroy(*params);
900 *params = nullptr;
901 return ret;
902 }
903
904 return ret;
905 }
906
OHTEST_CreateVectorHkdfParams(paramsVectorSpec paramInfo,OH_CryptoKdfParams ** params)907 static OH_Crypto_ErrCode OHTEST_CreateVectorHkdfParams(paramsVectorSpec paramInfo, OH_CryptoKdfParams **params)
908 {
909 OH_Crypto_ErrCode ret = CRYPTO_SUCCESS;
910 Crypto_DataBlob key = {.data = paramInfo.hkdfParams.key, .len = paramInfo.hkdfParams.keyLen};
911 Crypto_DataBlob salt = {.data = paramInfo.hkdfParams.salt, .len = paramInfo.hkdfParams.saltLen};
912 Crypto_DataBlob info = {.data = paramInfo.hkdfParams.info, .len = paramInfo.hkdfParams.infoLen};
913
914 ret = OH_CryptoKdfParams_Create("HKDF", params);
915 if (ret != CRYPTO_SUCCESS) {
916 return ret;
917 }
918 if (paramInfo.hkdfParams.key) {
919 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_KEY_DATABLOB, &key);
920 if (ret != CRYPTO_SUCCESS) {
921 OH_CryptoKdfParams_Destroy(*params);
922 *params = nullptr;
923 return ret;
924 }
925 }
926 if (paramInfo.hkdfParams.salt) {
927 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_SALT_DATABLOB, &salt);
928 if (ret != CRYPTO_SUCCESS) {
929 OH_CryptoKdfParams_Destroy(*params);
930 *params = nullptr;
931 return ret;
932 }
933 }
934 if (paramInfo.hkdfParams.info) {
935 ret = OH_CryptoKdfParams_SetParam(*params, CRYPTO_KDF_INFO_DATABLOB, &info);
936 if (ret != CRYPTO_SUCCESS) {
937 OH_CryptoKdfParams_Destroy(*params);
938 *params = nullptr;
939 return ret;
940 }
941 }
942
943 return ret;
944 }
945
946 KdfVectorSpec g_vectors[] = {
947 {
948 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA1", .keySize = 20,
949 .params.pbkdf2Params = {
950 .password = pbhdf2_sha1_password, .passLen = sizeof(pbhdf2_sha1_password),
951 .salt = pbhdf2_sha1_salt, .saltLen = sizeof(pbhdf2_sha1_salt),
952 .iterations = 2
953 },
954 .expectSecret = pbhdf2_sha1_expectSecret
955 }, // 0
956 {
957 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA224", .keySize = 20,
958 .params.pbkdf2Params = {
959 .password = pbhdf2_sha224_password, .passLen = sizeof(pbhdf2_sha224_password),
960 .salt = pbhdf2_sha224_salt, .saltLen = sizeof(pbhdf2_sha224_salt),
961 .iterations = 1
962 },
963 .expectSecret = pbhdf2_sha224_expectSecret
964 }, // 1
965 {
966 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA256", .keySize = 64,
967 .params.pbkdf2Params = {
968 .password = pbhdf2_sha256_password, .passLen = sizeof(pbhdf2_sha256_password),
969 .salt = pbhdf2_sha256_salt, .saltLen = sizeof(pbhdf2_sha256_salt),
970 .iterations = 1
971 },
972 .expectSecret = pbhdf2_sha256_expectSecret
973 }, // 2
974 {
975 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA384", .keySize = 20,
976 .params.pbkdf2Params = {
977 .password = pbhdf2_sha384_password, .passLen = sizeof(pbhdf2_sha384_password),
978 .salt = pbhdf2_sha384_salt, .saltLen = sizeof(pbhdf2_sha384_salt),
979 .iterations = 1
980 },
981 .expectSecret = pbhdf2_sha384_expectSecret
982 }, // 3
983 {
984 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SHA512", .keySize = 20,
985 .params.pbkdf2Params = {
986 .password = pbhdf2_sha512_password, .passLen = sizeof(pbhdf2_sha512_password),
987 .salt = pbhdf2_sha512_salt, .saltLen = sizeof(pbhdf2_sha512_salt),
988 .iterations = 1
989 },
990 .expectSecret = pbhdf2_sha512_expectSecret
991 }, // 4
992 {
993 .kdfType = OHTEST_KDF_PBKDF2, .algoName = "PBKDF2|SM3", .keySize = 20,
994 .params.pbkdf2Params = {
995 .password = pbhdf2_sm3_password, .passLen = sizeof(pbhdf2_sm3_password),
996 .salt = pbhdf2_sm3_salt, .saltLen = sizeof(pbhdf2_sm3_salt),
997 .iterations = 10000
998 },
999 .expectSecret = pbhdf2_sm3_expectSecret
1000 }, // 5
1001 {
1002 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA1", .keySize = 42,
1003 .params.hkdfParams = {
1004 .key = hkdf_sha1_key, .keyLen = sizeof(hkdf_sha1_key),
1005 .salt = hkdf_sha1_salt, .saltLen = sizeof(hkdf_sha1_salt),
1006 .info = hkdf_sha1_info, .infoLen = sizeof(hkdf_sha1_info),
1007 },
1008 .expectSecret = hkdf_sha1_expectSecret
1009 }, // 6
1010 {
1011 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA224", .keySize = 32,
1012 .params.hkdfParams = {
1013 .key = hkdf_sha224_key, .keyLen = sizeof(hkdf_sha224_key),
1014 .salt = hkdf_sha224_salt, .saltLen = sizeof(hkdf_sha224_salt),
1015 .info = hkdf_sha224_info, .infoLen = sizeof(hkdf_sha224_info),
1016 },
1017 .expectSecret = hkdf_sha224_expectSecret
1018 }, // 7
1019 {
1020 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA256", .keySize = 42,
1021 .params.hkdfParams = {
1022 .key = hkdf_sha256_key, .keyLen = sizeof(hkdf_sha256_key),
1023 .salt = hkdf_sha256_salt, .saltLen = sizeof(hkdf_sha256_salt),
1024 .info = hkdf_sha256_info, .infoLen = sizeof(hkdf_sha256_info),
1025 },
1026 .expectSecret = hkdf_sha256_expectSecret
1027 }, // 8
1028 {
1029 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA384", .keySize = 32,
1030 .params.hkdfParams = {
1031 .key = hkdf_sha384_key, .keyLen = sizeof(hkdf_sha384_key),
1032 .salt = hkdf_sha384_salt, .saltLen = sizeof(hkdf_sha384_salt),
1033 .info = hkdf_sha384_info, .infoLen = sizeof(hkdf_sha384_info),
1034 },
1035 .expectSecret = hkdf_sha384_expectSecret
1036 }, // 9
1037 {
1038 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SHA512", .keySize = 32,
1039 .params.hkdfParams = {
1040 .key = hkdf_sha512_key, .keyLen = sizeof(hkdf_sha512_key),
1041 .salt = hkdf_sha512_salt, .saltLen = sizeof(hkdf_sha512_salt),
1042 .info = hkdf_sha512_info, .infoLen = sizeof(hkdf_sha512_info),
1043 },
1044 .expectSecret = hkdf_sha512_expectSecret
1045 }, // 10
1046 {
1047 .kdfType = OHTEST_KDF_HKDF, .algoName = "HKDF|SM3", .keySize = 16,
1048 .params.hkdfParams = {
1049 .key = hkdf_sm3_key, .keyLen = sizeof(hkdf_sm3_key),
1050 .salt = hkdf_sm3_salt, .saltLen = sizeof(hkdf_sm3_salt),
1051 .info = hkdf_sm3_info, .infoLen = sizeof(hkdf_sm3_info),
1052 },
1053 .expectSecret = hkdf_sm3_expectSecret
1054 }, // 11
1055 };
1056 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkKdfNapiTest, KDF_VECTOR_TEST, ::testing::ValuesIn(g_vectors));
1057
1058 /**
1059 * @tc.number SUB_Security_CryptoFramework_NAPI_Kdf_Vector_Test_0100
1060 * @tc.name OHCryptoFrameworkKdfNapiTest/KDF_VECTOR_TEST.SUB_Security_CryptoFramework_NAPI_Kdf_Vector_Test_0100/x
1061 * @tc.desc algorithm is Kdf
1062 * @tc.size Medium
1063 * @tc.type Func
1064 * @tc.level Level0
1065 */
1066 HWTEST_P(KDF_VECTOR_TEST, SUB_Security_CryptoFramework_NAPI_Kdf_Vector_Test_0100, TestSize.Level0)
1067 {
1068 KdfVectorSpec infoSpec = GetParam();
1069 KdfType kdfType = infoSpec.kdfType;
1070 const char *algoName = infoSpec.algoName;
1071 int keySize = infoSpec.keySize;
1072 OH_CryptoKdfParams *params = nullptr;
1073 OH_CryptoKdf *ctx = nullptr;
1074 Crypto_DataBlob key = {.data = nullptr, .len = 0};
1075
1076 switch(kdfType) {
1077 case OHTEST_KDF_PBKDF2:
1078 EXPECT_EQ(OHTEST_CreateVectorPbkdf2Params(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
1079 break;
1080 case OHTEST_KDF_HKDF:
1081 EXPECT_EQ(OHTEST_CreateVectorHkdfParams(infoSpec.params, ¶ms), CRYPTO_SUCCESS);
1082 break;
1083 default:
1084 break;
1085 }
1086 EXPECT_EQ(OH_CryptoKdf_Create(algoName, &ctx), CRYPTO_SUCCESS);
1087 EXPECT_EQ(OH_CryptoKdf_Derive(ctx, params, keySize, &key), CRYPTO_SUCCESS);
1088 if (key.len == keySize) {
1089 EXPECT_TRUE(memcmp(key.data, infoSpec.expectSecret, keySize) == 0);
1090 }
1091 EXPECT_EQ(key.len, keySize);
1092
1093 OH_CryptoKdfParams_Destroy(params);
1094 OH_CryptoKdf_Destroy(ctx);
1095 OH_Crypto_FreeDataBlob(&key);
1096 }
1097
1098 } // namespace Unittest::CryptoFrameworkKdfNapiTest
1099