1 /*
2 * Copyright (c) 2024 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
20 #include "crypto_framework_sym_key_test.h"
21 #include "blob.h"
22 #include "log.h"
23
24 #include <gtest/gtest.h>
25
26 using namespace testing::ext;
27 namespace Unittest::CryptoFrameworkSymKeyNapiTest {
28 class OHCryptoFrameworkSymKeyNapiTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31
32 static void TearDownTestCase(void);
33
34 void SetUp();
35
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void OHCryptoFrameworkSymKeyNapiTest::SetUpTestCase(void)
40 {
41 }
42
TearDownTestCase(void)43 void OHCryptoFrameworkSymKeyNapiTest::TearDownTestCase(void)
44 {
45 }
46
SetUp()47 void OHCryptoFrameworkSymKeyNapiTest::SetUp()
48 {
49 }
50
TearDown()51 void OHCryptoFrameworkSymKeyNapiTest::TearDown()
52 {
53 }
54
55 class OHCryptoFrameworkSymKeyConvertNapiTest : public testing::Test {
56 public:
SetUpTestCase()57 static void SetUpTestCase() {};
58
TearDownTestCase()59 static void TearDownTestCase() {};
60 };
61
62 class SYMKEY_TEST : public testing::TestWithParam<SymKeySpec> {
63 public:
SetUpTestCase()64 static void SetUpTestCase() {}
TearDownTestCase()65 static void TearDownTestCase() {}
66 };
67
68 class SYMKEY_CONVERT_TEST : public testing::TestWithParam<SymKeySpec> {
69 public:
SetUpTestCase()70 static void SetUpTestCase() {}
TearDownTestCase()71 static void TearDownTestCase() {}
72 };
73
74 SymKeySpec g_symKeyData[] = {
75 {(uint8_t *)"AES128", OH_CRYPTO_AES_128_KEY_SIZE, (uint8_t *)"AES128"},
76 {(uint8_t *)"AES192", OH_CRYPTO_AES_192_KEY_SIZE, (uint8_t *)"AES192"},
77 {(uint8_t *)"AES256", OH_CRYPTO_AES_256_KEY_SIZE, (uint8_t *)"AES256"},
78 {(uint8_t *)"3DES192", OH_CRYPTO_3DES_192_KEY_SIZE, (uint8_t *)"3DES192"},
79 {(uint8_t *)"SM4_128", OH_CRYPTO_SM4_128_KEY_SIZE, (uint8_t *)"SM4128"},
80 {(uint8_t *)"HMAC|SHA1", OH_CRYPTO_HMAC_SHA1_KEY_SIZE, (uint8_t *)"HMAC160"},
81 {(uint8_t *)"HMAC|SHA224", OH_CRYPTO_HMAC_SHA224_KEY_SIZE, (uint8_t *)"HMAC224"},
82 {(uint8_t *)"HMAC|SHA256", OH_CRYPTO_HMAC_SHA256_KEY_SIZE, (uint8_t *)"HMAC256"},
83 {(uint8_t *)"HMAC|SHA384", OH_CRYPTO_HMAC_SHA384_KEY_SIZE, (uint8_t *)"HMAC384"},
84 {(uint8_t *)"HMAC|SHA512", OH_CRYPTO_HMAC_SHA512_KEY_SIZE, (uint8_t *)"HMAC512"},
85 {(uint8_t *)"HMAC|SM3", OH_CRYPTO_HMAC_SM3_KEY_SIZE, (uint8_t *)"HMAC256"},
86 };
87
88 SymKeySpec g_symKeyConvertData[] = {
89 {(uint8_t *)"HMAC", 1, (uint8_t *)"HMAC8"},
90 {(uint8_t *)"HMAC", 16, (uint8_t *)"HMAC128"},
91 {(uint8_t *)"HMAC", 64, (uint8_t *)"HMAC512"},
92 {(uint8_t *)"HMAC", 1024, (uint8_t *)"HMAC8192"},
93 {(uint8_t *)"HMAC", 4096, (uint8_t *)"HMAC32768"},
94 };
95
96 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkSymKeyNapiTest, SYMKEY_TEST, ::testing::ValuesIn(g_symKeyData));
97
98 /**
99 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_0100
100 * @tc.name OHCryptoFrameworkSymKeyNapiTest/SYMKEY_TEST.SUB_Security_CryptoFramework_NAPI_SymKey_Test_0100/x
101 * @tc.desc algorithm is Sym Key
102 * @tc.size Medium
103 * @tc.type Func
104 * @tc.level Level0
105 */
106 HWTEST_P(SYMKEY_TEST, SUB_Security_CryptoFramework_NAPI_SymKey_Test_0100, TestSize.Level0)
107 {
108 SymKeySpec symKeyData = GetParam();
109 OH_CryptoSymKeyGenerator *ctx = nullptr;
110 OH_CryptoSymKey *keyCtx = nullptr;
111 OH_CryptoSymKey *convertKeyCtx = nullptr;
112 OH_Crypto_ErrCode ret;
113 Crypto_DataBlob out = {.data = nullptr, .len = 0};
114 Crypto_DataBlob convertOut = {.data = nullptr, .len = 0};
115
116 ret = OH_CryptoSymKeyGenerator_Create((const char *)symKeyData.algName, &ctx);
117 EXPECT_EQ(ret, CRYPTO_SUCCESS);
118 ret = OH_CryptoSymKeyGenerator_Generate(ctx, &keyCtx);
119 EXPECT_EQ(ret, CRYPTO_SUCCESS);
120 const char *algoName1 = OH_CryptoSymKeyGenerator_GetAlgoName(ctx);
121 EXPECT_TRUE(memcmp((const char *)symKeyData.algName, algoName1, strlen(algoName1)) == 0);
122 const char *algoName2 = OH_CryptoSymKey_GetAlgoName(keyCtx);
123 EXPECT_TRUE(memcmp((const char *)symKeyData.getAlgName, algoName2, strlen(algoName2)) == 0);
124 ret = OH_CryptoSymKey_GetKeyData(keyCtx, &out);
125 EXPECT_EQ(ret, CRYPTO_SUCCESS);
126 ret = OH_CryptoSymKeyGenerator_Convert(ctx, &out, &convertKeyCtx);
127 EXPECT_EQ(ret, CRYPTO_SUCCESS);
128 ret = OH_CryptoSymKey_GetKeyData(convertKeyCtx, &convertOut);
129 EXPECT_EQ(ret, CRYPTO_SUCCESS);
130 EXPECT_TRUE(memcmp(out.data, convertOut.data, out.len) == 0);
131
132 OH_CryptoSymKeyGenerator_Destroy(ctx);
133 OH_CryptoSymKey_Destroy(keyCtx);
134 OH_CryptoSymKey_Destroy(convertKeyCtx);
135 HcfBlobDataClearAndFree((HcfBlob *)&out);
136 HcfBlobDataClearAndFree((HcfBlob *)&convertOut);
137 }
138
139 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkSymKeyConvertNapiTest, SYMKEY_CONVERT_TEST, ::testing::ValuesIn(g_symKeyConvertData));
140
141 /**
142 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_0200
143 * @tc.name OHCryptoFrameworkSymKeyConvertNapiTest/SYMKEY_CONVERT_TEST.SUB_Security_CryptoFramework_NAPI_SymKey_Test_0200/x
144 * @tc.desc algorithm is Sym Key
145 * @tc.size Medium
146 * @tc.type Func
147 * @tc.level Level0
148 */
149 HWTEST_P(SYMKEY_CONVERT_TEST, SUB_Security_CryptoFramework_NAPI_SymKey_Test_0200, TestSize.Level0)
150 {
151 SymKeySpec symKeyData = GetParam();
152 OH_CryptoSymKeyGenerator *ctx = nullptr;
153 OH_CryptoSymKey *convertKeyCtx = nullptr;
154 OH_Crypto_ErrCode ret;
155
156 uint8_t *testData = (uint8_t *)malloc(symKeyData.bits);
157 Crypto_DataBlob in = {
158 .data = reinterpret_cast<uint8_t *>(testData),
159 .len = symKeyData.bits
160 };
161 Crypto_DataBlob convertOut = {.data = nullptr, .len = 0};
162
163 ret = OH_CryptoSymKeyGenerator_Create((const char *)symKeyData.algName, &ctx);
164 EXPECT_EQ(ret, CRYPTO_SUCCESS);
165 ret = OH_CryptoSymKeyGenerator_Convert(ctx, &in, &convertKeyCtx);
166 EXPECT_EQ(ret, CRYPTO_SUCCESS);
167 const char *algoName = OH_CryptoSymKey_GetAlgoName(convertKeyCtx);
168 EXPECT_TRUE(memcmp((const char *)symKeyData.getAlgName, algoName, strlen(algoName)) == 0);
169 ret = OH_CryptoSymKey_GetKeyData(convertKeyCtx, &convertOut);
170 EXPECT_EQ(ret, CRYPTO_SUCCESS);
171 EXPECT_TRUE(memcmp(in.data, convertOut.data, in.len) == 0);
172
173 OH_CryptoSymKeyGenerator_Destroy(ctx);
174 OH_CryptoSymKey_Destroy(convertKeyCtx);
175 OH_Crypto_FreeDataBlob(&in);
176 HcfBlobDataClearAndFree((HcfBlob *)&convertOut);
177 }
178
179 /**
180 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_0300
181 * @tc.name OHCryptoFrameworkSymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_SymKey_Test_0300
182 * @tc.desc algorithm is Sym Key
183 * @tc.size Medium
184 * @tc.type Func
185 * @tc.level Level0
186 */
187 HWTEST_F(OHCryptoFrameworkSymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_SymKey_Test_0300, TestSize.Level0)
188 {
189 OH_CryptoSymKeyGenerator *ctx = nullptr;
190
191 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"RC4", &ctx), CRYPTO_NOT_SUPPORTED);
192 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES128", nullptr), CRYPTO_INVALID_PARAMS);
193 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"aes128", &ctx), CRYPTO_NOT_SUPPORTED);
194 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create(nullptr, &ctx), CRYPTO_INVALID_PARAMS);
195 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES225", &ctx), CRYPTO_NOT_SUPPORTED);
196 }
197
198 /**
199 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_0400
200 * @tc.name OHCryptoFrameworkSymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_SymKey_Test_0400
201 * @tc.desc algorithm is Sym Key
202 * @tc.size Medium
203 * @tc.type Func
204 * @tc.level Level0
205 */
206 HWTEST_F(OHCryptoFrameworkSymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_SymKey_Test_0400, TestSize.Level0)
207 {
208 OH_CryptoSymKeyGenerator *ctx = nullptr;
209 OH_CryptoSymKey *keyCtx = nullptr;
210
211 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES256", &ctx), CRYPTO_SUCCESS);
212 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(nullptr, &keyCtx), CRYPTO_INVALID_PARAMS);
213 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(ctx, nullptr), CRYPTO_INVALID_PARAMS);
214 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(nullptr, nullptr), CRYPTO_INVALID_PARAMS);
215
216 OH_CryptoSymKeyGenerator_Destroy(ctx);
217 }
218
219 /**
220 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_0500
221 * @tc.name OHCryptoFrameworkSymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_SymKey_Test_0500
222 * @tc.desc algorithm is Sym Key
223 * @tc.size Medium
224 * @tc.type Func
225 * @tc.level Level0
226 */
227 HWTEST_F(OHCryptoFrameworkSymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_SymKey_Test_0500, TestSize.Level0)
228 {
229 OH_CryptoSymKeyGenerator *ctx = nullptr;
230
231 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"HMAC|SHA256", &ctx), CRYPTO_SUCCESS);
232 EXPECT_EQ(OH_CryptoSymKeyGenerator_GetAlgoName(nullptr), nullptr);
233
234 OH_CryptoSymKeyGenerator_Destroy(ctx);
235 }
236
237 /**
238 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_0600
239 * @tc.name OHCryptoFrameworkSymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_SymKey_Test_0600
240 * @tc.desc algorithm is Sym Key
241 * @tc.size Medium
242 * @tc.type Func
243 * @tc.level Level0
244 */
245 HWTEST_F(OHCryptoFrameworkSymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_SymKey_Test_0600, TestSize.Level0)
246 {
247 OH_CryptoSymKeyGenerator *ctx = nullptr;
248 OH_CryptoSymKey *convertKeyCtx = nullptr;
249 const char *algName = "HMAC|SHA256";
250
251 uint8_t *testData1 = (uint8_t *)malloc(OH_CRYPTO_HMAC_SHA256_KEY_SIZE / 8 - 2);
252 Crypto_DataBlob in1 = {
253 .data = reinterpret_cast<uint8_t *>(testData1),
254 .len = OH_CRYPTO_HMAC_SHA256_KEY_SIZE / 8 - 2
255 };
256 uint8_t *testData2 = (uint8_t *)malloc(OH_CRYPTO_HMAC_SHA256_KEY_SIZE / 8 + 2);
257 Crypto_DataBlob in2 = {
258 .data = reinterpret_cast<uint8_t *>(testData2),
259 .len = OH_CRYPTO_HMAC_SHA256_KEY_SIZE / 8 + 2
260 };
261 uint8_t *testData3 = (uint8_t *)malloc(OH_CRYPTO_HMAC_SHA256_KEY_SIZE / 8);
262 Crypto_DataBlob in3 = {
263 .data = reinterpret_cast<uint8_t *>(testData3),
264 .len = OH_CRYPTO_HMAC_SHA256_KEY_SIZE / 8
265 };
266
267 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create(algName, &ctx), CRYPTO_SUCCESS);
268 EXPECT_EQ(OH_CryptoSymKeyGenerator_Convert(nullptr, &in3, &convertKeyCtx), CRYPTO_INVALID_PARAMS);
269 EXPECT_EQ(OH_CryptoSymKeyGenerator_Convert(ctx, nullptr, &convertKeyCtx), CRYPTO_INVALID_PARAMS);
270 EXPECT_EQ(OH_CryptoSymKeyGenerator_Convert(ctx, &in3, nullptr), CRYPTO_INVALID_PARAMS);
271 EXPECT_EQ(OH_CryptoSymKeyGenerator_Convert(ctx, &in1, &convertKeyCtx), CRYPTO_INVALID_PARAMS);
272 EXPECT_EQ(OH_CryptoSymKeyGenerator_Convert(ctx, &in2, &convertKeyCtx), CRYPTO_INVALID_PARAMS);
273
274 OH_CryptoSymKeyGenerator_Destroy(ctx);
275 OH_CryptoSymKey_Destroy(convertKeyCtx);
276 OH_Crypto_FreeDataBlob(&in1);
277 OH_Crypto_FreeDataBlob(&in2);
278 OH_Crypto_FreeDataBlob(&in3);
279 }
280
281 /**
282 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_0700
283 * @tc.name OHCryptoFrameworkSymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_SymKey_Test_0700
284 * @tc.desc algorithm is Sym Key
285 * @tc.size Medium
286 * @tc.type Func
287 * @tc.level Level0
288 */
289 HWTEST_F(OHCryptoFrameworkSymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_SymKey_Test_0700, TestSize.Level0)
290 {
291 OH_CryptoSymKeyGenerator *ctx = nullptr;
292 OH_CryptoSymKey *keyCtx = nullptr;
293 Crypto_DataBlob out = {.data = nullptr, .len = 0};
294
295 EXPECT_EQ(OH_CryptoSymKeyGenerator_Create((const char *)"AES192", &ctx), CRYPTO_SUCCESS);
296 EXPECT_EQ(OH_CryptoSymKeyGenerator_Generate(ctx, &keyCtx), CRYPTO_SUCCESS);
297 EXPECT_EQ(OH_CryptoSymKey_GetKeyData(nullptr, &out), CRYPTO_INVALID_PARAMS);
298 EXPECT_EQ(OH_CryptoSymKey_GetKeyData(keyCtx, nullptr), CRYPTO_INVALID_PARAMS);
299
300 OH_CryptoSymKeyGenerator_Destroy(ctx);
301 OH_CryptoSymKey_Destroy(keyCtx);
302 }
303
304 /**
305 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_0800
306 * @tc.name OHCryptoFrameworkSymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_SymKey_Test_0800
307 * @tc.desc algorithm is Sym Key
308 * @tc.size Medium
309 * @tc.type Func
310 * @tc.level Level0
311 */
312 HWTEST_F(OHCryptoFrameworkSymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_SymKey_Test_0800, TestSize.Level0)
313 {
314 const char *algName = "3DES192";
315 OH_CryptoSymKeyGenerator *ctx = nullptr;
316 OH_CryptoSymKey *convertKeyCtx = nullptr;
317 OH_Crypto_ErrCode ret;
318
319 uint8_t arr[] = {
320 0xba, 0x3d, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
321 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c,
322 0xba, 0x3b, 0xc2, 0x71, 0xab, 0xa0, 0x30, 0x72
323 };
324 Crypto_DataBlob convertBlob = {.data = arr, .len = sizeof(arr)};
325 Crypto_DataBlob convertOut = {.data = nullptr, .len = 0};
326
327 ret = OH_CryptoSymKeyGenerator_Create(algName, &ctx);
328 EXPECT_EQ(ret, CRYPTO_SUCCESS);
329 ret = OH_CryptoSymKeyGenerator_Convert(ctx, &convertBlob, &convertKeyCtx);
330 EXPECT_EQ(ret, CRYPTO_SUCCESS);
331 ret = OH_CryptoSymKey_GetKeyData(convertKeyCtx, &convertOut);
332 EXPECT_EQ(ret, CRYPTO_SUCCESS);
333 EXPECT_TRUE(memcmp(convertBlob.data, convertOut.data, convertBlob.len) == 0);
334
335 OH_CryptoSymKeyGenerator_Destroy(ctx);
336 OH_CryptoSymKey_Destroy(convertKeyCtx);
337 HcfBlobDataClearAndFree((HcfBlob *)&convertOut);
338 }
339
340 /**
341 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_0900
342 * @tc.name OHCryptoFrameworkSymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_SymKey_Test_0900
343 * @tc.desc algorithm is Sym Key
344 * @tc.size Medium
345 * @tc.type Func
346 * @tc.level Level0
347 */
348 HWTEST_F(OHCryptoFrameworkSymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_SymKey_Test_0900, TestSize.Level0)
349 {
350 const char *algName = "3DES192";
351 OH_CryptoSymKeyGenerator *ctx = nullptr;
352 OH_CryptoSymKey *convertKeyCtx = nullptr;
353 OH_Crypto_ErrCode ret;
354
355 uint8_t arr[] = {
356 0xba, 0x3d, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
357 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c,
358 0xba, 0x3b, 0xc2, 0x71, 0xab, 0xa0, 0x30,
359 };
360 Crypto_DataBlob convertBlob = {.data = arr, .len = sizeof(arr)};
361
362 ret = OH_CryptoSymKeyGenerator_Create(algName, &ctx);
363 EXPECT_EQ(ret, CRYPTO_SUCCESS);
364 ret = OH_CryptoSymKeyGenerator_Convert(ctx, &convertBlob, &convertKeyCtx);
365 EXPECT_EQ(ret, CRYPTO_INVALID_PARAMS);
366
367 OH_CryptoSymKeyGenerator_Destroy(ctx);
368 }
369
370 /**
371 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_1000
372 * @tc.name OHCryptoFrameworkSymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_SymKey_Test_1000
373 * @tc.desc algorithm is Sym Key
374 * @tc.size Medium
375 * @tc.type Func
376 * @tc.level Level0
377 */
378 HWTEST_F(OHCryptoFrameworkSymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_SymKey_Test_1000, TestSize.Level0)
379 {
380 const char *algName = "SM4_128";
381 OH_CryptoSymKeyGenerator *ctx = nullptr;
382 OH_CryptoSymKey *convertKeyCtx = nullptr;
383 OH_Crypto_ErrCode ret;
384
385 uint8_t arr[] = {
386 0xba, 0x3d, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
387 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c,
388 0xba,
389 };
390 Crypto_DataBlob convertBlob = {.data = arr, .len = sizeof(arr)};
391
392 ret = OH_CryptoSymKeyGenerator_Create(algName, &ctx);
393 EXPECT_EQ(ret, CRYPTO_SUCCESS);
394 ret = OH_CryptoSymKeyGenerator_Convert(ctx, &convertBlob, &convertKeyCtx);
395 EXPECT_EQ(ret, CRYPTO_INVALID_PARAMS);
396
397 OH_CryptoSymKeyGenerator_Destroy(ctx);
398 }
399
400 /**
401 * @tc.number SUB_Security_CryptoFramework_NAPI_SymKey_Test_1100
402 * @tc.name OHCryptoFrameworkSymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_SymKey_Test_1100
403 * @tc.desc algorithm is Sym Key
404 * @tc.size Medium
405 * @tc.type Func
406 * @tc.level Level0
407 */
408 HWTEST_F(OHCryptoFrameworkSymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_SymKey_Test_1100, TestSize.Level0)
409 {
410 const char *genAlgName = "HMAC|SHA256";
411 const char *conertAlgName = "AES256";
412 OH_CryptoSymKeyGenerator *genCtx = nullptr;
413 OH_CryptoSymKeyGenerator *convertCtx = nullptr;
414 OH_CryptoSymKey *keyCtx = nullptr;
415 OH_CryptoSymKey *convertKeyCtx = nullptr;
416 OH_Crypto_ErrCode ret;
417 Crypto_DataBlob out = {.data = nullptr, .len = 0};
418 Crypto_DataBlob convertOut = {.data = nullptr, .len = 0};
419
420 ret = OH_CryptoSymKeyGenerator_Create(genAlgName, &genCtx);
421 EXPECT_EQ(ret, CRYPTO_SUCCESS);
422 ret = OH_CryptoSymKeyGenerator_Generate(genCtx, &keyCtx);
423 EXPECT_EQ(ret, CRYPTO_SUCCESS);
424 ret = OH_CryptoSymKey_GetKeyData(keyCtx, &out);
425 EXPECT_EQ(ret, CRYPTO_SUCCESS);
426 ret = OH_CryptoSymKeyGenerator_Create(conertAlgName, &convertCtx);
427 EXPECT_EQ(ret, CRYPTO_SUCCESS);
428 ret = OH_CryptoSymKeyGenerator_Convert(convertCtx, &out, &convertKeyCtx);
429 EXPECT_EQ(ret, CRYPTO_SUCCESS);
430 ret = OH_CryptoSymKey_GetKeyData(convertKeyCtx, &convertOut);
431 EXPECT_EQ(ret, CRYPTO_SUCCESS);
432 EXPECT_TRUE(memcmp(out.data, convertOut.data, out.len) == 0);
433
434 OH_CryptoSymKeyGenerator_Destroy(genCtx);
435 OH_CryptoSymKeyGenerator_Destroy(convertCtx);
436 OH_CryptoSymKey_Destroy(keyCtx);
437 OH_CryptoSymKey_Destroy(convertKeyCtx);
438 HcfBlobDataClearAndFree((HcfBlob *)&out);
439 HcfBlobDataClearAndFree((HcfBlob *)&convertOut);
440 }
441
442 } // namespace Unittest::CryptoFrameworkSymKeyNapiTest
443