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_digest_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::CryptoFrameworkDigestNapiTest {
28 class OHCryptoFrameworkDigestNapiTest : 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 OHCryptoFrameworkDigestNapiTest::SetUpTestCase(void)
40 {
41 }
42
TearDownTestCase(void)43 void OHCryptoFrameworkDigestNapiTest::TearDownTestCase(void)
44 {
45 }
46
SetUp()47 void OHCryptoFrameworkDigestNapiTest::SetUp()
48 {
49 }
50
TearDown()51 void OHCryptoFrameworkDigestNapiTest::TearDown()
52 {
53 }
54
OH_CryptoDigestMultUpdate(void * args)55 void *OH_CryptoDigestMultUpdate(void *args)
56 {
57 MdMultSpec *in = (MdMultSpec *)args;
58 EXPECT_EQ(OH_CryptoDigest_Update(in->ctx, in->in), CRYPTO_SUCCESS);
59
60 return nullptr;
61 }
62
63 MdSpec g_mdData[] = {
64 {(uint8_t *)"MD5", OH_CRYPTO_MD5_DIGESTSIZE},
65 {(uint8_t *)"SHA1", OH_CRYPTO_SHA1_DIGESTSIZE},
66 {(uint8_t *)"SHA224", OH_CRYPTO_SHA224_DIGESTSIZE},
67 {(uint8_t *)"SHA256", OH_CRYPTO_SHA256_DIGESTSIZE},
68 {(uint8_t *)"SHA384", OH_CRYPTO_SHA384_DIGESTSIZE},
69 {(uint8_t *)"SHA512", OH_CRYPTO_SHA512_DIGESTSIZE},
70 {(uint8_t *)"SM3", OH_CRYPTO_SM3_DIGESTSIZE},
71 };
72
73 class MD_TEST : public testing::TestWithParam<MdSpec> {
74 public:
SetUpTestCase()75 static void SetUpTestCase() {}
TearDownTestCase()76 static void TearDownTestCase() {}
77 };
78
79 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkDigestNapiTest, MD_TEST, ::testing::ValuesIn(g_mdData));
80
81 /**
82 * @tc.number SUB_Security_CryptoFramework_NAPI_Digest_Test_0100
83 * @tc.name OHCryptoFrameworkDigestNapiTest/MD_TEST.SUB_Security_CryptoFramework_NAPI_Digest_Test_0100/x
84 * @tc.desc algorithm is Digest
85 * @tc.size Medium
86 * @tc.type Func
87 * @tc.level Level0
88 */
89 HWTEST_P(MD_TEST, SUB_Security_CryptoFramework_NAPI_Digest_Test_0100, TestSize.Level0)
90 {
91 MdSpec mdData = GetParam();
92 OH_Crypto_ErrCode ret;
93 OH_CryptoDigest *ctx = nullptr;
94 uint8_t testData[] = "0123456789";
95
96 Crypto_DataBlob in = {
97 .data = reinterpret_cast<uint8_t *>(testData),
98 .len = sizeof(testData)
99 };
100 Crypto_DataBlob out = {.data = nullptr, .len = 0};
101 int mdLen = 0;
102
103 ret = OH_CryptoDigest_Create((const char *)mdData.algName, &ctx);
104 EXPECT_EQ(ret, CRYPTO_SUCCESS);
105 ret = OH_CryptoDigest_Update(ctx, &in);
106 EXPECT_EQ(ret, CRYPTO_SUCCESS);
107 ret = OH_CryptoDigest_Final(ctx, &out);
108 EXPECT_EQ(ret, CRYPTO_SUCCESS);
109 mdLen = OH_CryptoDigest_GetLength(ctx);
110 EXPECT_EQ(mdLen, mdData.mdLen);
111 OH_DigestCrypto_Destroy(ctx);
112 HcfBlobDataClearAndFree((HcfBlob *)&out);
113 }
114
115 /**
116 * @tc.number SUB_Security_CryptoFramework_NAPI_Digest_Test_0200
117 * @tc.name OHCryptoFrameworkDigestNapiTest.SUB_Security_CryptoFramework_NAPI_Digest_Test_0200
118 * @tc.desc algorithm is Digest
119 * @tc.size Medium
120 * @tc.type Func
121 * @tc.level Level0
122 */
123 HWTEST_F(OHCryptoFrameworkDigestNapiTest, SUB_Security_CryptoFramework_NAPI_Digest_Test_0200, TestSize.Level0)
124 {
125 OH_CryptoDigest *ctx = nullptr;
126
127 EXPECT_EQ(OH_CryptoDigest_Create("MD9", &ctx), CRYPTO_INVALID_PARAMS);
128 EXPECT_EQ(OH_CryptoDigest_Create("MD5", nullptr), CRYPTO_INVALID_PARAMS);
129 EXPECT_EQ(OH_CryptoDigest_Create(nullptr, &ctx), CRYPTO_INVALID_PARAMS);
130 }
131
132 /**
133 * @tc.number SUB_Security_CryptoFramework_NAPI_Digest_Test_0300
134 * @tc.name OHCryptoFrameworkDigestNapiTest.SUB_Security_CryptoFramework_NAPI_Digest_Test_0300
135 * @tc.desc algorithm is Digest
136 * @tc.size Medium
137 * @tc.type Func
138 * @tc.level Level0
139 */
140 HWTEST_F(OHCryptoFrameworkDigestNapiTest, SUB_Security_CryptoFramework_NAPI_Digest_Test_0300, TestSize.Level0)
141 {
142 OH_CryptoDigest *ctx = nullptr;
143 uint8_t testData[] = "0123456789";
144 Crypto_DataBlob in = {
145 .data = reinterpret_cast<uint8_t *>(testData),
146 .len = sizeof(testData)
147 };
148 Crypto_DataBlob in2 = {
149 .data = reinterpret_cast<uint8_t *>(testData),
150 .len = 0
151 };
152
153 EXPECT_EQ(OH_CryptoDigest_Create("SHA1", &ctx), CRYPTO_SUCCESS);
154 EXPECT_EQ(OH_CryptoDigest_Update(nullptr, &in), CRYPTO_INVALID_PARAMS);
155 EXPECT_EQ(OH_CryptoDigest_Update(ctx, nullptr), CRYPTO_INVALID_PARAMS);
156 EXPECT_EQ(OH_CryptoDigest_Update(ctx, &in2), CRYPTO_INVALID_PARAMS);
157 OH_DigestCrypto_Destroy(ctx);
158 }
159
160 /**
161 * @tc.number SUB_Security_CryptoFramework_NAPI_Digest_Test_0400
162 * @tc.name OHCryptoFrameworkDigestNapiTest.SUB_Security_CryptoFramework_NAPI_Digest_Test_0400
163 * @tc.desc algorithm is Digest
164 * @tc.size Medium
165 * @tc.type Func
166 * @tc.level Level0
167 */
168 HWTEST_F(OHCryptoFrameworkDigestNapiTest, SUB_Security_CryptoFramework_NAPI_Digest_Test_0400, TestSize.Level0)
169 {
170 OH_CryptoDigest *ctx = nullptr;
171 uint8_t testData[] = "0123456789";
172 Crypto_DataBlob in = {
173 .data = reinterpret_cast<uint8_t *>(testData),
174 .len = sizeof(testData)
175 };
176 Crypto_DataBlob out = {.data = nullptr, .len = 0};
177
178 EXPECT_EQ(OH_CryptoDigest_Create("SHA224", &ctx), CRYPTO_SUCCESS);
179 EXPECT_EQ(OH_CryptoDigest_Update(ctx, &in), CRYPTO_SUCCESS);
180 EXPECT_EQ(OH_CryptoDigest_Final(ctx, nullptr), CRYPTO_INVALID_PARAMS);
181 EXPECT_EQ(OH_CryptoDigest_Final(nullptr, &out), CRYPTO_INVALID_PARAMS);
182 EXPECT_EQ(OH_CryptoDigest_GetLength(nullptr), CRYPTO_INVALID_PARAMS);
183 EXPECT_EQ(OH_CryptoDigest_GetAlgoName(nullptr), OH_CRYPTO_RETURN_NULL);
184 OH_DigestCrypto_Destroy(ctx);
185 }
186
187 /**
188 * @tc.number SUB_Security_CryptoFramework_NAPI_Digest_Test_0500
189 * @tc.name OHCryptoFrameworkDigestNapiTest/MD_TEST.SUB_Security_CryptoFramework_NAPI_Digest_Test_0500/x
190 * @tc.desc algorithm is Digest
191 * @tc.size Medium
192 * @tc.type Func
193 * @tc.level Level0
194 */
195 HWTEST_P(MD_TEST, Security_CryptoFramework_NAPI_Digest_Test_0500, TestSize.Level0)
196 {
197 MdSpec mdData = GetParam();
198 OH_Crypto_ErrCode ret;
199 OH_CryptoDigest *ctx = nullptr;
200 uint8_t *testData = (uint8_t *)malloc(OH_CRYPTO_DIGEST_DATA_MAX);
201 Crypto_DataBlob in = {
202 .data = reinterpret_cast<uint8_t *>(testData),
203 .len = OH_CRYPTO_DIGEST_DATA_MAX
204 };
205 Crypto_DataBlob out = {.data = nullptr, .len = 0};
206 int mdLen = 0;
207
208 ret = OH_CryptoDigest_Create((const char *)mdData.algName, &ctx);
209 EXPECT_EQ(ret, CRYPTO_SUCCESS);
210 ret = OH_CryptoDigest_Update(ctx, &in);
211 EXPECT_EQ(ret, CRYPTO_SUCCESS);
212 ret = OH_CryptoDigest_Final(ctx, &out);
213 EXPECT_EQ(ret, CRYPTO_SUCCESS);
214 mdLen = OH_CryptoDigest_GetLength(ctx);
215 EXPECT_EQ(mdLen, mdData.mdLen);
216 OH_DigestCrypto_Destroy(ctx);
217 HcfBlobDataClearAndFree((HcfBlob *)&out);
218 free(testData);
219 }
220
221 /**
222 * @tc.number SUB_Security_CryptoFramework_NAPI_Digest_Test_0600
223 * @tc.name OHCryptoFrameworkDigestNapiTest/MD_TEST.SUB_Security_CryptoFramework_NAPI_Digest_Test_0600/x
224 * @tc.desc algorithm is Digest
225 * @tc.size Medium
226 * @tc.type Func
227 * @tc.level Level0
228 */
229 HWTEST_P(MD_TEST, SUB_Security_CryptoFramework_NAPI_Digest_Test_0600, TestSize.Level0)
230 {
231 MdSpec mdData = GetParam();
232 OH_Crypto_ErrCode ret;
233 OH_CryptoDigest *ctx = nullptr;
234 uint8_t testData[] = "0123456789";
235 Crypto_DataBlob in = {
236 .data = reinterpret_cast<uint8_t *>(testData),
237 .len = sizeof(testData)
238 };
239 Crypto_DataBlob out = {.data = nullptr, .len = 0};
240
241 ret = OH_CryptoDigest_Create((const char *)mdData.algName, &ctx);
242 EXPECT_EQ(ret, CRYPTO_SUCCESS);
243 for (int i = 0; i < OH_CRYPTO_ITERATIONS_NUMBER; i++) {
244 ret = OH_CryptoDigest_Update(ctx, &in);
245 EXPECT_EQ(ret, CRYPTO_SUCCESS);
246 }
247 ret = OH_CryptoDigest_Final(ctx, &out);
248 EXPECT_EQ(ret, CRYPTO_SUCCESS);
249
250
251 OH_DigestCrypto_Destroy(ctx);
252 HcfBlobDataClearAndFree((HcfBlob *)&out);
253 }
254
255 /**
256 * @tc.number SUB_Security_CryptoFramework_NAPI_Digest_Test_0700
257 * @tc.name OHCryptoFrameworkDigestNapiTest/MD_TEST.SUB_Security_CryptoFramework_NAPI_Digest_Test_0700/x
258 * @tc.desc algorithm is Digest
259 * @tc.size Medium
260 * @tc.type Func
261 * @tc.level Level0
262 */
263 HWTEST_P(MD_TEST, SUB_Security_CryptoFramework_NAPI_Digest_Test_0700, TestSize.Level0)
264 {
265 MdSpec mdData = GetParam();
266 OH_Crypto_ErrCode ret;
267 OH_CryptoDigest *ctx = nullptr;
268 uint8_t testData[] = "0123456789";
269 pthread_t thrd[OH_CRYPTO_ITERATIONS_NUMBER];
270 Crypto_DataBlob in = {
271 .data = reinterpret_cast<uint8_t *>(testData),
272 .len = sizeof(testData)
273 };
274
275 Crypto_DataBlob out = {.data = nullptr, .len = 0};
276
277 ret = OH_CryptoDigest_Create((const char *)mdData.algName, &ctx);
278 MdMultSpec multIn = {
279 .ctx = ctx,
280 .in = &in
281 };
282 EXPECT_EQ(ret, CRYPTO_SUCCESS);
283 for (int i = 0; i < OH_CRYPTO_ITERATIONS_NUMBER; i++) {
284 int thrd_ret = pthread_create(&thrd[i], nullptr, OH_CryptoDigestMultUpdate, &multIn);
285 EXPECT_EQ(thrd_ret, CRYPTO_SUCCESS);
286 }
287 for (int i = 0; i < OH_CRYPTO_ITERATIONS_NUMBER; i++) {
288 int thrd_ret = pthread_join(thrd[i], nullptr);
289 EXPECT_EQ(thrd_ret, CRYPTO_SUCCESS);
290 }
291 ret = OH_CryptoDigest_Final(ctx, &out);
292 EXPECT_EQ(ret, CRYPTO_SUCCESS);
293 OH_DigestCrypto_Destroy(ctx);
294 HcfBlobDataClearAndFree((HcfBlob *)&out);
295 }
296
297 /**
298 * @tc.number SUB_Security_CryptoFramework_NAPI_Digest_Test_0800
299 * @tc.name OHCryptoFrameworkDigestNapiTest/MD_TEST.SUB_Security_CryptoFramework_NAPI_Digest_Test_0800/x
300 * @tc.desc algorithm is Digest
301 * @tc.size Medium
302 * @tc.type Func
303 * @tc.level Level0
304 */
305 HWTEST_P(MD_TEST, SUB_Security_CryptoFramework_NAPI_Digest_Test_0800, TestSize.Level0)
306 {
307 MdSpec mdData = GetParam();
308 OH_Crypto_ErrCode ret;
309 OH_CryptoDigest *ctx = nullptr;
310 Crypto_DataBlob out = {.data = nullptr, .len = 0};
311
312 ret = OH_CryptoDigest_Create((const char *)mdData.algName, &ctx);
313 EXPECT_EQ(ret, CRYPTO_SUCCESS);
314 ret = OH_CryptoDigest_Final(ctx, &out);
315 EXPECT_EQ(ret, CRYPTO_SUCCESS);
316 const char *algoName = OH_CryptoDigest_GetAlgoName(ctx);
317 EXPECT_TRUE(memcmp((const char *)mdData.algName, algoName, strlen(algoName)) == 0);
318 OH_DigestCrypto_Destroy(ctx);
319 HcfBlobDataClearAndFree((HcfBlob *)&out);
320 }
321
322 /**
323 * @tc.number SUB_Security_CryptoFramework_NAPI_Digest_Test_0900
324 * @tc.name OHCryptoFrameworkDigestNapiTest/MD_TEST.SUB_Security_CryptoFramework_NAPI_Digest_Test_0900/x
325 * @tc.desc algorithm is Digest
326 * @tc.size Medium
327 * @tc.type Func
328 * @tc.level Level0
329 */
330 HWTEST_P(MD_TEST, SUB_Security_CryptoFramework_NAPI_Digest_Test_0900, TestSize.Level0)
331 {
332 MdSpec mdData = GetParam();
333 OH_Crypto_ErrCode ret;
334 OH_CryptoDigest *ctx = nullptr;
335 uint8_t *testData = (uint8_t *)malloc(OH_CRYPTO_DIGEST_DATA_MAX);
336 Crypto_DataBlob out = {.data = nullptr, .len = 0};
337 int isBlockSize = 20;
338 int offset = 0;
339
340 ret = OH_CryptoDigest_Create((const char *)mdData.algName, &ctx);
341 EXPECT_EQ(ret, CRYPTO_SUCCESS);
342 for (int i = 0; i < OH_CRYPTO_DIGEST_DATA_MAX / isBlockSize; i++) {
343 Crypto_DataBlob in = {
344 .data = reinterpret_cast<uint8_t *>(testData + offset),
345 .len = isBlockSize
346 };
347 ret = OH_CryptoDigest_Update(ctx, &in);
348 EXPECT_EQ(ret, CRYPTO_SUCCESS);
349 offset += isBlockSize;
350 }
351 ret = OH_CryptoDigest_Final(ctx, &out);
352 EXPECT_EQ(ret, CRYPTO_SUCCESS);
353
354 OH_DigestCrypto_Destroy(ctx);
355 HcfBlobDataClearAndFree((HcfBlob *)&out);
356 free(testData);
357 }
358
359 } // namespace Unittest::CryptoFrameworkDigestNapiTest
360