1 /*
2 * Copyright (c) 2023 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 "dlp_crypt_test.h"
17 #include <cstring>
18 #include <fstream>
19 #include <iostream>
20 #include <thread>
21 #include <openssl/err.h>
22 #include <openssl/evp.h>
23 #include <openssl/rand.h>
24 #include "accesstoken_kit.h"
25 #include "c_mock_common.h"
26 #include "dlp_crypt.h"
27 #include "dlp_permission.h"
28 #include "dlp_permission_log.h"
29 #include "token_setproc.h"
30
31 using namespace testing::ext;
32 using namespace OHOS::Security::DlpPermission;
33 using namespace std;
34 using namespace OHOS::Security::AccessToken;
35
36 extern "C" {
37 extern const EVP_MD* GetOpensslAlg(uint32_t alg);
38 }
39
40 namespace {
41 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_DLP_PERMISSION, "DlpCryptTest"};
42 static const int32_t DEFAULT_USERID = 100;
43 static AccessTokenID g_selfTokenId = 0;
44 static long USEC_PER_SEC = 1000000L;
45 constexpr int THOUSAND = 1000;
46 constexpr int SIXTEEN = 16;
47 constexpr int TWENTYFOUR = 24;
48 constexpr int TWENTYFIVE = 25;
49 uint8_t g_key[32] = { 0xdc, 0x7c, 0x8d, 0xe, 0xeb, 0x41, 0x4b, 0xb0, 0x8e, 0x24, 0x8, 0x32, 0xc7, 0x88, 0x96, 0xb6,
50 0x2, 0x69, 0x65, 0x49, 0xaf, 0x3c, 0xa7, 0x8f, 0x38, 0x3d, 0xe3, 0xf1, 0x23, 0xb6, 0x22, 0xfb };
51 uint8_t g_iv[16] = { 0x90, 0xd5, 0xe2, 0x45, 0xaa, 0xeb, 0xa0, 0x9, 0x61, 0x45, 0xd1, 0x48, 0x4a, 0xaf, 0xc9, 0xf9 };
52 static const int ENC_BUF_LEN = 10 * 1024 * 1024;
53
Dumpptr(uint8_t * ptr,uint32_t len)54 void Dumpptr(uint8_t *ptr, uint32_t len)
55 {
56 uint8_t *abc = ptr;
57 for (uint32_t i = 0; i < len; i++) {
58 printf("%x ", *abc);
59 abc++;
60 }
61 printf("\n");
62 }
63 }
64
SetUpTestCase()65 void DlpCryptTest::SetUpTestCase()
66 {
67 g_selfTokenId = GetSelfTokenID();
68 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(DEFAULT_USERID, "com.ohos.dlpmanager", 0);
69 SetSelfTokenID(tokenId);
70 }
71
TearDownTestCase()72 void DlpCryptTest::TearDownTestCase()
73 {
74 SetSelfTokenID(g_selfTokenId);
75 }
76
SetUp()77 void DlpCryptTest::SetUp() {}
78
TearDown()79 void DlpCryptTest::TearDown() {}
80
CheckParams(DlpUsageSpec * usage,DlpBlob * key,DlpBlob * mIn,DlpBlob * mEnc)81 static void CheckParams(DlpUsageSpec* usage, DlpBlob* key, DlpBlob* mIn, DlpBlob* mEnc)
82 {
83 DLP_LOG_INFO(LABEL, "CheckParams");
84 usage->mode = THOUSAND;
85 ASSERT_EQ(DLP_PARSE_ERROR_OPERATION_UNSUPPORTED, DlpOpensslAesEncrypt(key, usage, mIn, mEnc));
86 usage->mode = DLP_MODE_CTR;
87 // key len 16 when DlpOpensslAesEncrypt
88 key->size = SIXTEEN;
89 ASSERT_EQ(DLP_OK, DlpOpensslAesEncrypt(key, usage, mIn, mEnc));
90 // key len 24 when DlpOpensslAesEncrypt
91 key->size = TWENTYFOUR;
92 ASSERT_EQ(DLP_OK, DlpOpensslAesEncrypt(key, usage, mIn, mEnc));
93 // key len invalid when DlpOpensslAesEncrypt
94 key->size = TWENTYFIVE;
95 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpOpensslAesEncrypt(key, usage, mIn, mEnc));
96 }
97
98 /**
99 * @tc.name: DlpOpensslAesEncrypt001
100 * @tc.desc: Dlp encrypt test with invalid key.
101 * @tc.type: FUNC
102 * @tc.require:SR000GVIG3
103 */
104 HWTEST_F(DlpCryptTest, DlpOpensslAesEncrypt001, TestSize.Level1)
105 {
106 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncrypt001");
107 struct DlpCipherParam tagIv = {{16, g_iv}};
108 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
109
110 uint8_t input[16] = "aaaaaaaaaaaaaaa";
111 uint8_t enc[16] = {0};
112 struct DlpBlob message = {15, input};
113 struct DlpBlob cipherText = {15, enc};
114
115 // key = nullptr
116 int32_t ret = DlpOpensslAesEncrypt(nullptr, &usageSpec, &message, &cipherText);
117 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
118 }
119
120 /**
121 * @tc.name: DlpOpensslAesEncrypt002
122 * @tc.desc: Dlp encrypt test with invalid usageSpec.
123 * @tc.type: FUNC
124 * @tc.require:SR000GVIG3
125 */
126 HWTEST_F(DlpCryptTest, DlpOpensslAesEncrypt002, TestSize.Level1)
127 {
128 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncrypt002");
129
130 uint8_t input[16] = "aaaaaaaaaaaaaaa";
131 uint8_t enc[16] = {0};
132 struct DlpBlob key = {32, g_key};
133 struct DlpBlob message = {15, input};
134 struct DlpBlob cipherText = {15, enc};
135
136 // usageSpec = nullptr
137 int32_t ret = DlpOpensslAesEncrypt(&key, nullptr, &message, &cipherText);
138 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
139 }
140
141 /**
142 * @tc.name: DlpOpensslAesEncrypt003
143 * @tc.desc: Dlp encrypt test with invalid message.
144 * @tc.type: FUNC
145 * @tc.require:SR000GVIG3
146 */
147 HWTEST_F(DlpCryptTest, DlpOpensslAesEncrypt003, TestSize.Level1)
148 {
149 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncrypt003");
150 struct DlpCipherParam tagIv = {{16, g_iv}};
151 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
152
153 uint8_t enc[16] = {0};
154 struct DlpBlob key = {32, g_key};
155 struct DlpBlob cipherText = {15, enc};
156
157 // message = nullptr
158 int32_t ret = DlpOpensslAesEncrypt(&key, &usageSpec, nullptr, &cipherText);
159 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
160 }
161
162 /**
163 * @tc.name: DlpOpensslAesEncrypt004
164 * @tc.desc: Dlp encrypt test with invalid cipherText.
165 * @tc.type: FUNC
166 * @tc.require:SR000GVIG3
167 */
168 HWTEST_F(DlpCryptTest, DlpOpensslAesEncrypt004, TestSize.Level1)
169 {
170 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncrypt004");
171 struct DlpCipherParam tagIv = {{16, g_iv}};
172 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
173
174 uint8_t input[16] = "aaaaaaaaaaaaaaa";
175 struct DlpBlob message = {15, input};
176 struct DlpBlob key = {32, g_key};
177
178 // cipherText = nullptr
179 int32_t ret = DlpOpensslAesEncrypt(&key, &usageSpec, &message, nullptr);
180 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
181 }
182
183 /**
184 * @tc.name: DlpOpensslAesDecrypt001
185 * @tc.desc: Dlp encrypt test with invalid key.
186 * @tc.type: FUNC
187 * @tc.require:SR000GVIG3
188 */
189 HWTEST_F(DlpCryptTest, DlpOpensslAesDecrypt001, TestSize.Level1)
190 {
191 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecrypt001");
192 struct DlpCipherParam tagIv = {{16, g_iv}};
193 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
194
195 uint8_t input[16] = "aaaaaaaaaaaaaaa";
196 uint8_t dec[16] = {0};
197 struct DlpBlob message = {15, input};
198 struct DlpBlob plainText = {15, dec};
199
200 // key = nullptr
201 int32_t ret = DlpOpensslAesDecrypt(nullptr, &usageSpec, &message, &plainText);
202 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
203 }
204
205 /**
206 * @tc.name: DlpOpensslAesDecrypt002
207 * @tc.desc: Dlp encrypt test with invalid usageSpec.
208 * @tc.type: FUNC
209 * @tc.require:SR000GVIG3
210 */
211 HWTEST_F(DlpCryptTest, DlpOpensslAesDecrypt002, TestSize.Level1)
212 {
213 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecrypt002");
214
215 uint8_t input[16] = "aaaaaaaaaaaaaaa";
216 uint8_t dec[16] = {0};
217 struct DlpBlob key = {32, g_key};
218 struct DlpBlob message = {15, input};
219 struct DlpBlob plainText = {15, dec};
220
221 // usageSpec = nullptr
222 int32_t ret = DlpOpensslAesDecrypt(&key, nullptr, &message, &plainText);
223 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
224 }
225
226 /**
227 * @tc.name: DlpOpensslAesDecrypt003
228 * @tc.desc: Dlp encrypt test with invalid message.
229 * @tc.type: FUNC
230 * @tc.require:SR000GVIG3
231 */
232 HWTEST_F(DlpCryptTest, DlpOpensslAesDecrypt003, TestSize.Level1)
233 {
234 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecrypt003");
235 struct DlpCipherParam tagIv = {{16, g_iv}};
236 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
237
238 uint8_t enc[16] = {0};
239 struct DlpBlob key = {32, g_key};
240 struct DlpBlob plainText = {15, enc};
241
242 // message = nullptr
243 int32_t ret = DlpOpensslAesDecrypt(&key, &usageSpec, nullptr, &plainText);
244 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
245 }
246
247 /**
248 * @tc.name: DlpOpensslAesDecrypt004
249 * @tc.desc: Dlp encrypt test with invalid plainText.
250 * @tc.type: FUNC
251 * @tc.require:SR000GVIG3
252 */
253 HWTEST_F(DlpCryptTest, DlpOpensslAesDecrypt004, TestSize.Level1)
254 {
255 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecrypt004");
256 struct DlpCipherParam tagIv = {{16, g_iv}};
257 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
258
259 uint8_t input[16] = "aaaaaaaaaaaaaaa";
260 struct DlpBlob message = {15, input};
261 struct DlpBlob key = {32, g_key};
262
263 // plainText = nullptr
264 int32_t ret = DlpOpensslAesDecrypt(&key, &usageSpec, &message, nullptr);
265 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
266 }
267
268 /**
269 * @tc.name: DlpOpensslAesEncryptInit001
270 * @tc.desc: Dlp aes init test with invalid cryptoCtx
271 * @tc.type: FUNC
272 * @tc.require:SR000GVIG3
273 */
274 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptInit001, TestSize.Level1)
275 {
276 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptInit001");
277 struct DlpBlob key = {32, g_key};
278 struct DlpCipherParam tagIv = {{16, g_iv}};
279 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
280
281 // *cryptoCtx = nullptr
282 int32_t ret = DlpOpensslAesEncryptInit(nullptr, &key, &usageSpec);
283 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
284 }
285
286 /**
287 * @tc.name: DlpOpensslAesEncryptInit002
288 * @tc.desc: Dlp aes init test with invalid key
289 * @tc.type: FUNC
290 * @tc.require:SR000GVIG3
291 */
292 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptInit002, TestSize.Level1)
293 {
294 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptInit002");
295 struct DlpCipherParam tagIv = {{16, g_iv}};
296 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
297 void* ctx = nullptr;
298
299 // key = nullptr
300 int32_t ret = DlpOpensslAesEncryptInit(&ctx, nullptr, &usageSpec);
301 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
302 }
303
304 /**
305 * @tc.name: DlpOpensslAesEncryptInit003
306 * @tc.desc: Dlp aes init test with invalid usageSpec
307 * @tc.type: FUNC
308 * @tc.require:SR000GVIG3
309 */
310 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptInit003, TestSize.Level1)
311 {
312 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptInit003");
313 void* ctx = nullptr;
314 struct DlpBlob key = {32, g_key};
315
316 // usageSpec = nullptr
317 int32_t ret = DlpOpensslAesEncryptInit(&ctx, &key, nullptr);
318 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
319 }
320
321 /**
322 * @tc.name: DlpOpensslAesEncryptInit004
323 * @tc.desc: Dlp aes init test with openssl abnormal branch
324 * @tc.type: FUNC
325 * @tc.require:SR000GVIG3
326 */
327 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptInit004, TestSize.Level1)
328 {
329 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptInit004");
330 void* ctx = nullptr;
331 struct DlpBlob key = {32, g_key};
332 struct DlpCipherParam tagIv = {{16, g_iv}};
333 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
334
335 // EVP_CIPHER_CTX_new failed when OpensslAesCipherCryptInit
336 DlpCMockCondition condition;
337 condition.mockSequence = { true };
338 SetMockConditions("EVP_CIPHER_CTX_new", condition);
339 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec));
340 CleanMockConditions();
341
342 // EVP_aes_256_ctr failed when OpensslAesCipherCryptInit
343 condition.mockSequence = { true };
344 SetMockConditions("EVP_aes_256_ctr", condition);
345 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec));
346 CleanMockConditions();
347
348 // EVP_EncryptInit_ex failed when OpensslAesCipherCryptInit
349 condition.mockSequence = { true };
350 SetMockConditions("EVP_EncryptInit_ex", condition);
351 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec));
352 CleanMockConditions();
353
354 // EVP_EncryptInit_ex first success second failed when OpensslAesCipherCryptInit
355 condition.mockSequence = { false, true };
356 SetMockConditions("EVP_EncryptInit_ex", condition);
357 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec));
358 CleanMockConditions();
359
360 // EVP_CIPHER_CTX_set_padding failed when OpensslAesCipherCryptInit
361 condition.mockSequence = { true };
362 SetMockConditions("EVP_CIPHER_CTX_set_padding", condition);
363 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec));
364 CleanMockConditions();
365
366 // usage.mode is not DLP_MODE_CTR when DlpOpensslAesDecrypt
367 usageSpec.mode = 1000;
368 ASSERT_EQ(DLP_PARSE_ERROR_OPERATION_UNSUPPORTED, DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec));
369 usageSpec.mode = DLP_MODE_CTR;
370 }
371
372 /**
373 * @tc.name: DlpOpensslAesEncryptUpdate001
374 * @tc.desc: DlpOpensslAesEncryptUpdate with invalid cryptoCtx
375 * @tc.type: FUNC
376 * @tc.require:SR000GVIG3
377 */
378 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptUpdate001, TestSize.Level1)
379 {
380 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptUpdate001");
381 struct DlpBlob message = {32, g_key};
382 struct DlpBlob cipherText = {32, g_key};
383
384 // cryptoCtx = nullptr
385 int32_t ret = DlpOpensslAesEncryptUpdate(nullptr, &message, &cipherText);
386 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
387 }
388
389 /**
390 * @tc.name: DlpOpensslAesEncryptUpdate002
391 * @tc.desc: DlpOpensslAesEncryptUpdate with invalid message
392 * @tc.type: FUNC
393 * @tc.require:SR000GVIG3
394 */
395 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptUpdate002, TestSize.Level1)
396 {
397 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptUpdate002");
398 struct DlpBlob key = {32, g_key};
399 struct DlpCipherParam tagIv = {{16, g_iv}};
400 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
401
402 uint8_t enc[16] = {0};
403 struct DlpBlob cipherText = {15, enc};
404
405 void* ctx;
406 int32_t ret = DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec);
407 ASSERT_EQ(0, ret);
408
409 // message = nullptr
410 ret = DlpOpensslAesEncryptUpdate(ctx, nullptr, &cipherText);
411 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
412
413 struct DlpBlob message = {15, nullptr};
414
415 // message len is not 0, but data is nullptr
416 ret = DlpOpensslAesEncryptUpdate(ctx, &message, &cipherText);
417 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
418 }
419
420 /**
421 * @tc.name: DlpOpensslAesEncryptUpdate003
422 * @tc.desc: DlpOpensslAesEncryptUpdate with invalid cipherText
423 * @tc.type: FUNC
424 * @tc.require:SR000GVIG3
425 */
426 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptUpdate003, TestSize.Level1)
427 {
428 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptUpdate003");
429 struct DlpBlob key = {32, g_key};
430 struct DlpCipherParam tagIv = {{16, g_iv}};
431 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
432
433 uint8_t input[16] = "aaaaaaaaaaaaaaa";
434 struct DlpBlob message = {15, input};
435
436 void* ctx;
437 int32_t ret = DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec);
438 ASSERT_EQ(0, ret);
439
440 // cipherText = nullptr
441 ret = DlpOpensslAesEncryptUpdate(ctx, &message, nullptr);
442 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
443 }
444
445 /**
446 * @tc.name: DlpOpensslAesEncryptUpdate004
447 * @tc.desc: DlpOpensslAesEncryptUpdate with openssl abnormal branch
448 * @tc.type: FUNC
449 * @tc.require:SR000GVIG3
450 */
451 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptUpdate004, TestSize.Level1)
452 {
453 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptUpdate004");
454 struct DlpBlob key = {32, g_key};
455 struct DlpCipherParam tagIv = {{16, g_iv}};
456 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
457
458 uint8_t input[16] = "aaaaaaaaaaaaaaa";
459 struct DlpBlob message = {15, input};
460 uint8_t enc[16] = {0};
461 struct DlpBlob cipherText = {15, enc};
462
463 void* ctx;
464 int32_t ret = DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec);
465 ASSERT_EQ(0, ret);
466
467 struct DlpOpensslAesCtx* contex = static_cast<struct DlpOpensslAesCtx*>(ctx);
468 void *tmpCtx = contex->append;
469 contex->append = nullptr;
470 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpOpensslAesEncryptUpdate(ctx, &message, &cipherText));
471 contex->append = tmpCtx;
472
473 // EVP_EncryptUpdate failed when OpensslAesCipherEncryptUpdate
474 DlpCMockCondition condition;
475 condition.mockSequence = { true };
476 SetMockConditions("EVP_EncryptUpdate", condition);
477 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncryptUpdate(ctx, &message, &cipherText));
478 CleanMockConditions();
479
480 contex->mode = 1000;
481 ASSERT_EQ(DLP_PARSE_ERROR_OPERATION_UNSUPPORTED, DlpOpensslAesEncryptUpdate(ctx, &message, &cipherText));
482 contex->mode = DLP_MODE_CTR;
483 }
484
485 /**
486 * @tc.name: DlpOpensslAesEncryptFinal001
487 * @tc.desc: DlpOpensslAesEncryptFinal with invalid cryptoCtx
488 * @tc.type: FUNC
489 * @tc.require:SR000GVIG3
490 */
491 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptFinal001, TestSize.Level1)
492 {
493 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptFinal001");
494 struct DlpBlob message = {32, g_key};
495 struct DlpBlob cipherText = {32, g_key};
496
497 // cryptoCtx = nullptr
498 int32_t ret = DlpOpensslAesEncryptFinal(nullptr, &message, &cipherText);
499 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
500
501 // cryptoCtx.append = nullptr
502 DlpOpensslAesCtx* cryptoCtx = reinterpret_cast<DlpOpensslAesCtx*>(calloc(1, sizeof(DlpOpensslAesCtx)));
503 ASSERT_NE(nullptr, cryptoCtx);
504 cryptoCtx->mode = DLP_MODE_CTR;
505 cryptoCtx->padding = OPENSSL_CTX_PADDING_ENABLE;
506 cryptoCtx->append = nullptr;
507 ret = DlpOpensslAesEncryptFinal(reinterpret_cast<void**>(&cryptoCtx), &message, &cipherText);
508 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
509 free(cryptoCtx);
510 }
511
512 /**
513 * @tc.name: DlpOpensslAesEncryptFinal002
514 * @tc.desc: DlpOpensslAesEncryptFinal with invalid message
515 * @tc.type: FUNC
516 * @tc.require:SR000GVIG3
517 */
518 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptFinal002, TestSize.Level1)
519 {
520 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptFinal002");
521 struct DlpBlob key = {32, g_key};
522 struct DlpCipherParam tagIv = {{16, g_iv}};
523 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
524
525 uint8_t input[16] = "aaaaaaaaaaaaaaa";
526 uint8_t enc[16] = {0};
527 struct DlpBlob message = {15, input};
528 struct DlpBlob cipherText = {15, enc};
529
530 void* ctx;
531 int32_t ret = DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec);
532 ASSERT_EQ(0, ret);
533 message.size = 1;
534 cipherText.size = 1;
535 int i = 0;
536 while (i < 15) {
537 ret = DlpOpensslAesEncryptUpdate(ctx, &message, &cipherText);
538 ASSERT_EQ(0, ret);
539 message.data = message.data + 1;
540 cipherText.data = cipherText.data + 1;
541 i++;
542 }
543
544 // message = nullptr
545 ret = DlpOpensslAesEncryptFinal(&ctx, nullptr, &cipherText);
546 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
547 DlpOpensslAesHalFreeCtx(&ctx);
548 }
549
550 /**
551 * @tc.name: DlpOpensslAesEncryptFinal003
552 * @tc.desc: DlpOpensslAesEncryptFinal with invalid cipherText
553 * @tc.type: FUNC
554 * @tc.require:SR000GVIG3
555 */
556 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptFinal003, TestSize.Level1)
557 {
558 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptFinal003");
559 struct DlpBlob key = {32, g_key};
560 struct DlpCipherParam tagIv = {{16, g_iv}};
561 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
562
563 uint8_t input[16] = "aaaaaaaaaaaaaaa";
564 uint8_t enc[16] = {0};
565 struct DlpBlob message = {15, input};
566 struct DlpBlob cipherText = {15, enc};
567
568 void* ctx;
569 int32_t ret = DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec);
570 ASSERT_EQ(0, ret);
571 message.size = 1;
572 cipherText.size = 1;
573 int i = 0;
574 while (i < 15) {
575 ret = DlpOpensslAesEncryptUpdate(ctx, &message, &cipherText);
576 ASSERT_EQ(0, ret);
577 message.data = message.data + 1;
578 cipherText.data = cipherText.data + 1;
579 i++;
580 }
581
582 // cipherText = nullptr
583 ret = DlpOpensslAesEncryptFinal(&ctx, &message, nullptr);
584 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
585 DlpOpensslAesHalFreeCtx(&ctx);
586 }
587
588 /**
589 * @tc.name: DlpOpensslAesEncryptFinal004
590 * @tc.desc: DlpOpensslAesEncryptFinal with invalid mode
591 * @tc.type: FUNC
592 * @tc.require:SR000GVIG3
593 */
594 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptFinal004, TestSize.Level1)
595 {
596 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptFinal003");
597 struct DlpBlob key = {32, g_key};
598 struct DlpCipherParam tagIv = {{16, g_iv}};
599 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
600
601 uint8_t input[16] = "aaaaaaaaaaaaaaa";
602 uint8_t enc[16] = {0};
603 struct DlpBlob message = {15, input};
604 struct DlpBlob cipherText = {15, enc};
605
606 void* ctx;
607 int32_t ret = DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec);
608 ASSERT_EQ(0, ret);
609 message.size = 1;
610 cipherText.size = 1;
611 int i = 0;
612 while (i < 15) {
613 ret = DlpOpensslAesEncryptUpdate(ctx, &message, &cipherText);
614 ASSERT_EQ(0, ret);
615 message.data = message.data + 1;
616 cipherText.data = cipherText.data + 1;
617 i++;
618 }
619
620 // mode is invalid
621 struct DlpOpensslAesCtx* contex = static_cast<struct DlpOpensslAesCtx*>(ctx);
622 contex->mode = 1000;
623 ret = DlpOpensslAesEncryptFinal(&ctx, &message, &cipherText);
624 EXPECT_EQ(DLP_PARSE_ERROR_OPERATION_UNSUPPORTED, ret);
625 DlpOpensslAesHalFreeCtx(&ctx);
626 }
627
628 /**
629 * @tc.name: DlpOpensslAesEncryptFinal005
630 * @tc.desc: DlpOpensslAesEncryptFinal with openssl EVP_CIPHER_CTX_new branch
631 * @tc.type: FUNC
632 * @tc.require:SR000GVIG3
633 */
634 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptFinal005, TestSize.Level1)
635 {
636 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptFinal005");
637 struct DlpBlob key = {32, g_key};
638 struct DlpCipherParam tagIv = {{16, g_iv}};
639 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
640
641 uint8_t input[16] = "aaaaaaaaaaaaaaa";
642 uint8_t enc[16] = {0};
643 struct DlpBlob message = {15, input};
644 struct DlpBlob cipherText = {15, enc};
645
646 void* ctx;
647 int32_t ret = DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec);
648 ASSERT_EQ(0, ret);
649 message.size = 1;
650 cipherText.size = 1;
651 int i = 0;
652 while (i < 15) {
653 ret = DlpOpensslAesEncryptUpdate(ctx, &message, &cipherText);
654 ASSERT_EQ(0, ret);
655 message.data = message.data + 1;
656 cipherText.data = cipherText.data + 1;
657 i++;
658 }
659
660 // EVP_EncryptUpdate fail in OpensslAesCipherEncryptFinalThree
661 DlpCMockCondition condition;
662 condition.mockSequence = { true };
663 SetMockConditions("EVP_EncryptUpdate", condition);
664 EXPECT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncryptFinal(&ctx, &message, &cipherText));
665 CleanMockConditions();
666 DlpOpensslAesHalFreeCtx(&ctx);
667 }
668
669 /**
670 * @tc.name: DlpOpensslAesEncryptFinal006
671 * @tc.desc: DlpOpensslAesEncryptFinal with openssl abnormal branch
672 * @tc.type: FUNC
673 * @tc.require:SR000GVIG3
674 */
675 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptFinal006, TestSize.Level1)
676 {
677 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptFinal006");
678 struct DlpBlob key = {32, g_key};
679 struct DlpCipherParam tagIv = {{16, g_iv}};
680 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
681
682 uint8_t input[16] = "aaaaaaaaaaaaaaa";
683 uint8_t enc[16] = {0};
684 struct DlpBlob message = {15, input};
685 struct DlpBlob cipherText = {15, enc};
686
687 void* ctx;
688 int32_t ret = DlpOpensslAesEncryptInit(&ctx, &key, &usageSpec);
689 ASSERT_EQ(0, ret);
690 message.size = 1;
691 cipherText.size = 1;
692 int i = 0;
693 while (i < 15) {
694 ret = DlpOpensslAesEncryptUpdate(ctx, &message, &cipherText);
695 ASSERT_EQ(0, ret);
696 message.data = message.data + 1;
697 cipherText.data = cipherText.data + 1;
698 i++;
699 }
700
701 // EVP_EncryptFinal_ex fail in OpensslAesCipherEncryptFinalThree
702 DlpCMockCondition condition;
703 condition.mockSequence = { true };
704 SetMockConditions("EVP_EncryptFinal_ex", condition);
705 EXPECT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncryptFinal(&ctx, &message, &cipherText));
706 CleanMockConditions();
707 DlpOpensslAesHalFreeCtx(&ctx);
708 }
709
710 /**
711 * @tc.name: DlpOpensslAesDecryptInit001
712 * @tc.desc: Dlp aes init test with invalid cryptoCtx
713 * @tc.type: FUNC
714 * @tc.require:SR000GVIG3
715 */
716 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptInit001, TestSize.Level1)
717 {
718 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptInit001");
719 struct DlpBlob key = {32, g_key};
720 struct DlpCipherParam tagIv = {{16, g_iv}};
721 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
722
723 // *cryptoCtx = nullptr
724 int32_t ret = DlpOpensslAesDecryptInit(nullptr, &key, &usageSpec);
725 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
726 }
727
728 /**
729 * @tc.name: DlpOpensslAesDecryptInit002
730 * @tc.desc: Dlp aes init test with invalid key
731 * @tc.type: FUNC
732 * @tc.require:SR000GVIG3
733 */
734 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptInit002, TestSize.Level1)
735 {
736 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptInit002");
737 struct DlpCipherParam tagIv = {{16, g_iv}};
738 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
739 void* ctx = nullptr;
740
741 // key = nullptr
742 int32_t ret = DlpOpensslAesDecryptInit(&ctx, nullptr, &usageSpec);
743 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
744 }
745
746 /**
747 * @tc.name: DlpOpensslAesDecryptInit003
748 * @tc.desc: Dlp aes init test with invalid usageSpec
749 * @tc.type: FUNC
750 * @tc.require:SR000GVIG3
751 */
752 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptInit003, TestSize.Level1)
753 {
754 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptInit003");
755 void* ctx = nullptr;
756 struct DlpBlob key = {32, g_key};
757
758 // usageSpec = nullptr
759 int32_t ret = DlpOpensslAesDecryptInit(&ctx, &key, nullptr);
760 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
761 }
762
763 /**
764 * @tc.name: DlpOpensslAesDecryptInit004
765 * @tc.desc: Dlp aes init test with openssl abnormal branch
766 * @tc.type: FUNC
767 * @tc.require:SR000GVIG3
768 */
769 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptInit004, TestSize.Level1)
770 {
771 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptInit004");
772
773 struct DlpBlob key = {32, g_key};
774 struct DlpCipherParam tagIv = {{16, g_iv}};
775 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
776 void* ctx = nullptr;
777
778 // EVP_CIPHER_CTX_new failed when OpensslAesCipherCryptInit
779 DlpCMockCondition condition;
780 condition.mockSequence = { true };
781 SetMockConditions("EVP_CIPHER_CTX_new", condition);
782 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesDecryptInit(&ctx, &key, &usageSpec));
783 CleanMockConditions();
784
785 // usage.mode is not DLP_MODE_CTR when DlpOpensslAesDecrypt
786 usageSpec.mode = 1000;
787 ASSERT_EQ(DLP_PARSE_ERROR_OPERATION_UNSUPPORTED, DlpOpensslAesDecryptInit(&ctx, &key, &usageSpec));
788 usageSpec.mode = DLP_MODE_CTR;
789 }
790
791 /**
792 * @tc.name: DlpOpensslAesDecryptUpdate001
793 * @tc.desc: DlpOpensslAesDecryptUpdate with invalid cryptoCtx
794 * @tc.type: FUNC
795 * @tc.require:SR000GVIG3
796 */
797 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptUpdate001, TestSize.Level1)
798 {
799 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptUpdate001");
800 struct DlpBlob message = {32, g_key};
801 struct DlpBlob plainText = {32, g_key};
802
803 // cryptoCtx = nullptr
804 int32_t ret = DlpOpensslAesDecryptUpdate(nullptr, &message, &plainText);
805 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
806 }
807
808 /**
809 * @tc.name: DlpOpensslAesDecryptUpdate002
810 * @tc.desc: DlpOpensslAesDecryptUpdate with invalid message
811 * @tc.type: FUNC
812 * @tc.require:SR000GVIG3
813 */
814 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptUpdate002, TestSize.Level1)
815 {
816 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptUpdate002");
817 struct DlpBlob key = {32, g_key};
818 struct DlpCipherParam tagIv = {{16, g_iv}};
819 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
820 uint8_t dec[16] = {0};
821 struct DlpBlob plainText = {15, dec};
822 void* ctx = nullptr;
823 int32_t ret = DlpOpensslAesDecryptInit(&ctx, &key, &usageSpec);
824 ASSERT_EQ(0, ret);
825
826 // message = nullptr
827 ret = DlpOpensslAesDecryptUpdate(ctx, nullptr, &plainText);
828 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
829 DlpOpensslAesHalFreeCtx(&ctx);
830 }
831
832 /**
833 * @tc.name: DlpOpensslAesDecryptUpdate003
834 * @tc.desc: DlpOpensslAesDecryptUpdate with invalid plainText
835 * @tc.type: FUNC
836 * @tc.require:SR000GVIG3
837 */
838 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptUpdate003, TestSize.Level1)
839 {
840 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptUpdate003");
841 struct DlpBlob key = {32, g_key};
842 struct DlpCipherParam tagIv = {{16, g_iv}};
843 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
844 uint8_t input[16] = "aaaaaaaaaaaaaaa";
845 struct DlpBlob message = {15, input};
846 void* ctx = nullptr;
847 int32_t ret = DlpOpensslAesDecryptInit(&ctx, &key, &usageSpec);
848 ASSERT_EQ(0, ret);
849
850 // plainText = nullptr
851 ret = DlpOpensslAesDecryptUpdate(ctx, &message, nullptr);
852 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
853 DlpOpensslAesHalFreeCtx(&ctx);
854 }
855
856 /**
857 * @tc.name: DlpOpensslAesDecryptUpdate004
858 * @tc.desc: DlpOpensslAesDecryptUpdate with openssl abnormal branch
859 * @tc.type: FUNC
860 * @tc.require:SR000GVIG3
861 */
862 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptUpdate004, TestSize.Level1)
863 {
864 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptUpdate004");
865 struct DlpBlob key = {32, g_key};
866 struct DlpCipherParam tagIv = {{16, g_iv}};
867 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
868 uint8_t input[16] = "aaaaaaaaaaaaaaa";
869 struct DlpBlob message = {15, input};
870 uint8_t enc[16] = {0};
871 struct DlpBlob cipherText = {15, enc};
872 void* ctx = nullptr;
873 int32_t ret = DlpOpensslAesDecryptInit(&ctx, &key, &usageSpec);
874 ASSERT_EQ(0, ret);
875
876 // ctx append nullptr
877 struct DlpOpensslAesCtx* aesCtx = static_cast<struct DlpOpensslAesCtx*>(ctx);
878 void *backup = aesCtx->append;
879 aesCtx->append = nullptr;
880 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpOpensslAesDecryptUpdate(ctx, &message, &cipherText));
881 aesCtx->append = backup;
882
883 // EVP_DecryptUpdate failed
884 DlpCMockCondition condition;
885 condition.mockSequence = { true };
886 SetMockConditions("EVP_DecryptUpdate", condition);
887 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesDecryptUpdate(ctx, &message, &cipherText));
888 CleanMockConditions();
889
890 // mode invalid
891 aesCtx->mode = 1000;
892 EXPECT_EQ(DLP_PARSE_ERROR_OPERATION_UNSUPPORTED, DlpOpensslAesDecryptUpdate(ctx, &message, &cipherText));
893 aesCtx->mode = DLP_MODE_CTR;
894 DlpOpensslAesHalFreeCtx(&ctx);
895 }
896
897
898 /**
899 * @tc.name: DlpOpensslAesDecryptFinal001
900 * @tc.desc: DlpOpensslAesDecryptFinal with invalid cryptoCtx
901 * @tc.type: FUNC
902 * @tc.require:SR000GVIG3
903 */
904 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptFinal001, TestSize.Level1)
905 {
906 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptFinal001");
907 struct DlpBlob message = {32, g_key};
908 struct DlpBlob cipherText = {32, g_key};
909
910 // cryptoCtx = nullptr
911 int32_t ret = DlpOpensslAesDecryptFinal(nullptr, &message, &cipherText);
912 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
913 }
914
915 /**
916 * @tc.name: DlpOpensslAesDecryptFinal002
917 * @tc.desc: DlpOpensslAesDecryptFinal with invalid message
918 * @tc.type: FUNC
919 * @tc.require:SR000GVIG3
920 */
921 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptFinal002, TestSize.Level1)
922 {
923 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptFinal002");
924 struct DlpBlob key = {32, g_key};
925 struct DlpCipherParam tagIv = {{16, g_iv}};
926 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
927
928 uint8_t input[16] = "aaaaaaaaaaaaaaa";
929 uint8_t enc[16] = {0};
930 struct DlpBlob message = {15, input};
931 struct DlpBlob cipherText = {15, enc};
932
933 void* ctx;
934 int32_t ret = DlpOpensslAesDecryptInit(&ctx, &key, &usageSpec);
935 ASSERT_EQ(0, ret);
936 message.size = 1;
937 cipherText.size = 1;
938 int i = 0;
939 while (i < 15) {
940 ret = DlpOpensslAesDecryptUpdate(ctx, &message, &cipherText);
941 ASSERT_EQ(0, ret);
942 message.data = message.data + 1;
943 cipherText.data = cipherText.data + 1;
944 i++;
945 }
946
947 // message = nullptr
948 ret = DlpOpensslAesDecryptFinal(&ctx, nullptr, &cipherText);
949 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
950 DlpOpensslAesHalFreeCtx(&ctx);
951 }
952
953 /**
954 * @tc.name: DlpOpensslAesDecryptFinal003
955 * @tc.desc: DlpOpensslAesDecryptFinal with invalid cipherText
956 * @tc.type: FUNC
957 * @tc.require:SR000GVIG3
958 */
959 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptFinal003, TestSize.Level1)
960 {
961 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptFinal003");
962 struct DlpBlob key = {32, g_key};
963 struct DlpCipherParam tagIv = {{16, g_iv}};
964 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
965
966 uint8_t input[16] = "aaaaaaaaaaaaaaa";
967 uint8_t enc[16] = {0};
968 struct DlpBlob message = {15, input};
969 struct DlpBlob cipherText = {15, enc};
970
971 void* ctx;
972 int32_t ret = DlpOpensslAesDecryptInit(&ctx, &key, &usageSpec);
973 ASSERT_EQ(0, ret);
974 message.size = 1;
975 cipherText.size = 1;
976 int i = 0;
977 while (i < 15) {
978 ret = DlpOpensslAesDecryptUpdate(ctx, &message, &cipherText);
979 ASSERT_EQ(0, ret);
980 message.data = message.data + 1;
981 cipherText.data = cipherText.data + 1;
982 i++;
983 }
984
985 // cipherText = nullptr
986 ret = DlpOpensslAesDecryptFinal(&ctx, &message, nullptr);
987 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
988 DlpOpensslAesHalFreeCtx(&ctx);
989 }
990
991 /**
992 * @tc.name: DlpOpensslAesDecryptFinal004
993 * @tc.desc: DlpOpensslAesDecryptFinal with openssl abnormal branch
994 * @tc.type: FUNC
995 * @tc.require:SR000GVIG3
996 */
997 HWTEST_F(DlpCryptTest, DlpOpensslAesDecryptFinal004, TestSize.Level1)
998 {
999 DLP_LOG_INFO(LABEL, "DlpOpensslAesDecryptFinal004");
1000 struct DlpBlob key = {32, g_key};
1001 struct DlpCipherParam tagIv = {{16, g_iv}};
1002 struct DlpUsageSpec usageSpec = {DLP_MODE_CTR, &tagIv};
1003
1004 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1005 uint8_t enc[16] = {0};
1006 struct DlpBlob message = {15, input};
1007 struct DlpBlob cipherText = {15, enc};
1008
1009 void* ctx;
1010 int32_t ret = DlpOpensslAesDecryptInit(&ctx, &key, &usageSpec);
1011 ASSERT_EQ(0, ret);
1012 message.size = 1;
1013 cipherText.size = 1;
1014 int i = 0;
1015 while (i < 15) {
1016 ret = DlpOpensslAesDecryptUpdate(ctx, &message, &cipherText);
1017 ASSERT_EQ(0, ret);
1018 message.data = message.data + 1;
1019 cipherText.data = cipherText.data + 1;
1020 i++;
1021 }
1022
1023 // ctx mode invalid
1024 struct DlpOpensslAesCtx* contex = static_cast<struct DlpOpensslAesCtx*>(ctx);
1025 contex->mode = 1000;
1026 EXPECT_EQ(DLP_PARSE_ERROR_OPERATION_UNSUPPORTED, DlpOpensslAesDecryptFinal(&ctx, &message, &cipherText));
1027 contex->mode = DLP_MODE_CTR;
1028
1029 // ctx append null
1030 void *backup = contex->append;
1031 contex->append = nullptr;
1032 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpOpensslAesDecryptFinal(&ctx, &message, &cipherText));
1033 contex->append = backup;
1034
1035 // EVP_DecryptUpdate fail
1036 ASSERT_EQ(0, DlpOpensslAesDecryptInit(&ctx, &key, &usageSpec));
1037 DlpCMockCondition condition;
1038 condition.mockSequence = { true };
1039 SetMockConditions("EVP_DecryptUpdate", condition);
1040 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesDecryptFinal(&ctx, &message, &cipherText));
1041 CleanMockConditions();
1042
1043 // EVP_DecryptFinal_ex fail
1044 ASSERT_EQ(0, DlpOpensslAesDecryptInit(&ctx, &key, &usageSpec));
1045 condition.mockSequence = { true };
1046 SetMockConditions("EVP_DecryptFinal_ex", condition);
1047 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesDecryptFinal(&ctx, &message, &cipherText));
1048 CleanMockConditions();
1049 DlpOpensslAesHalFreeCtx(&ctx);
1050 }
1051
1052 /**
1053 * @tc.name: DlpOpensslAesEncryptAndDecrypt001
1054 * @tc.desc: Dlp encrypt && decrypt test.
1055 * @tc.type: FUNC
1056 * @tc.require:SR000GVIG3
1057 */
1058 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptAndDecrypt001, TestSize.Level1)
1059 {
1060 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptAndDecrypt001");
1061 struct DlpBlob key = { 32, nullptr };
1062 key.data = g_key;
1063
1064 struct DlpCipherParam tagIv = { .iv = { .data = nullptr, .size = 16}};
1065 tagIv.iv.data = g_iv;
1066 struct DlpUsageSpec usage = {
1067 .mode = DLP_MODE_CTR,
1068 .algParam = &tagIv
1069 };
1070
1071 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1072 uint8_t enc[16] = {0};
1073 uint8_t dec[16] = {0};
1074 struct DlpBlob mIn = {
1075 .data = nullptr,
1076 .size = 15
1077 };
1078 mIn.data = input;
1079 struct DlpBlob mEnc = {
1080 .data = nullptr,
1081 .size = 15
1082 };
1083 mEnc.data = enc;
1084 struct DlpBlob mDec = {
1085 .data = nullptr,
1086 .size = 15
1087 };
1088 mDec.data = dec;
1089 DlpOpensslAesEncrypt(&key, &usage, &mIn, &mEnc);
1090 DlpOpensslAesDecrypt(&key, &usage, &mEnc, &mDec);
1091 cout << "input hexdump:";
1092 Dumpptr(input, 16);
1093 cout << "enc hexdump:";
1094 Dumpptr(enc, 16);
1095 cout << "output hexdump:";
1096 Dumpptr(dec, 16);
1097 int32_t ret = strcmp(reinterpret_cast<char *>(input), reinterpret_cast<char *>(dec));
1098 ASSERT_EQ(0, ret);
1099 }
1100
1101 /**
1102 * @tc.name: DlpOpensslAesEncryptAndDecrypt002
1103 * @tc.desc: Dlp encrypt && decrypt test for split interface
1104 * @tc.type: FUNC
1105 * @tc.require:SR000GVIG3
1106 */
1107 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptAndDecrypt002, TestSize.Level1)
1108 {
1109 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptAndDecrypt002");
1110 struct DlpBlob key = { 32, nullptr };
1111 key.data = g_key;
1112 struct DlpCipherParam tagIv = { .iv = { .data = nullptr, .size = 16}};
1113 tagIv.iv.data = g_iv;
1114 struct DlpUsageSpec usage = { .mode = DLP_MODE_CTR, .algParam = &tagIv};
1115 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1116 uint8_t enc[16] = {0};
1117 uint8_t dec[16] = {0};
1118 struct DlpBlob mIn = { .data = input, .size = 15};
1119 struct DlpBlob mEnc = { .data = enc, .size = 15};
1120 struct DlpBlob mDec = { .data = dec, .size = 15};
1121 struct DlpBlob mNull = { .data = nullptr, .size = 0};
1122 void *ctx;
1123 int i = 0;
1124 DlpOpensslAesEncryptInit(&ctx, &key, &usage);
1125 mIn.size = mEnc.size = 1;
1126 while (i < 15) {
1127 DlpOpensslAesEncryptUpdate(ctx, &mIn, &mEnc);
1128 mIn.data = mIn.data + 1;
1129 mEnc.data = mEnc.data + 1;
1130 i++;
1131 }
1132 DlpOpensslAesEncryptFinal(&ctx, &mNull, &mEnc);
1133 DlpOpensslAesHalFreeCtx(&ctx);
1134 DlpOpensslAesDecryptInit(&ctx, &key, &usage);
1135 i = 0;
1136 mEnc.data = enc;
1137 mEnc.size = mDec.size = 1;
1138 while (i < 15) {
1139 DlpOpensslAesDecryptUpdate(ctx, &mEnc, &mDec);
1140 mEnc.data = mEnc.data + 1;
1141 mDec.data = mDec.data + 1;
1142 i++;
1143 }
1144 DlpOpensslAesDecryptFinal(&ctx, &mNull, &mDec);
1145 DlpOpensslAesHalFreeCtx(&ctx);
1146 ASSERT_EQ(0, strcmp(reinterpret_cast<char *>(input), reinterpret_cast<char *>(dec)));
1147 }
1148
1149 /**
1150 * @tc.name: DlpOpensslAesEncryptAndDecrypt003
1151 * @tc.desc: Dlp encrypt && decrypt test.
1152 * @tc.type: FUNC
1153 * @tc.require:SR000GVIG3
1154 */
1155 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptAndDecrypt003, TestSize.Level1)
1156 {
1157 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptAndDecrypt003");
1158 struct DlpBlob key = { 32, nullptr };
1159 key.data = g_key;
1160
1161 struct DlpCipherParam tagIv = { .iv = { .data = nullptr, .size = 16}};
1162 tagIv.iv.data = g_iv;
1163 struct DlpUsageSpec usage = {
1164 .mode = DLP_MODE_CTR,
1165 .algParam = &tagIv
1166 };
1167
1168 uint8_t *input = static_cast<uint8_t *>(malloc(ENC_BUF_LEN));
1169 uint8_t *enc = static_cast<uint8_t *>(malloc(ENC_BUF_LEN));
1170 uint8_t *dec = static_cast<uint8_t *>(malloc(ENC_BUF_LEN));
1171
1172 struct DlpBlob mIn = {
1173 .data = nullptr,
1174 .size = ENC_BUF_LEN
1175 };
1176 mIn.data = input;
1177 struct DlpBlob mEnc = {
1178 .data = nullptr,
1179 .size = ENC_BUF_LEN
1180 };
1181 mEnc.data = enc;
1182 struct DlpBlob mDec = {
1183 .data = nullptr,
1184 .size = ENC_BUF_LEN
1185 };
1186 mDec.data = dec;
1187
1188 struct timeval start, end, diff;
1189 gettimeofday(&start, nullptr);
1190
1191 DlpOpensslAesEncrypt(&key, &usage, &mIn, &mEnc);
1192 gettimeofday(&end, nullptr);
1193 timersub(&end, &start, &diff);
1194 int runtimeUs = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;
1195 std::cout << "10M date encrypt time use: " << runtimeUs << "(us) " << std::endl;
1196
1197 gettimeofday(&start, nullptr);
1198 int32_t ret = DlpOpensslAesDecrypt(&key, &usage, &mEnc, &mDec);
1199 gettimeofday(&end, nullptr);
1200 timersub(&end, &start, &diff);
1201 runtimeUs = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;
1202 std::cout << "10M date decrypt time use: " << runtimeUs << "(us) " << std::endl;
1203 ASSERT_EQ(0, ret);
1204 free(input);
1205 free(enc);
1206 free(dec);
1207 }
1208
1209 /**
1210 * @tc.name: DlpOpensslAesEncryptAndDecrypt004
1211 * @tc.desc: Dlp encrypt && decrypt test with invalid args.
1212 * @tc.type: FUNC
1213 * @tc.require:SR000GVIG3
1214 */
1215 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptAndDecrypt004, TestSize.Level1)
1216 {
1217 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptAndDecrypt004");
1218 int32_t ret;
1219
1220 ret = DlpOpensslAesEncrypt(nullptr, nullptr, nullptr, nullptr);
1221 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1222 ret = DlpOpensslAesDecrypt(nullptr, nullptr, nullptr, nullptr);
1223 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1224 }
1225
1226 /**
1227 * @tc.name: DlpOpensslAesEncryptAndDecrypt005
1228 * @tc.desc: Dlp encrypt && decrypt openssl abnormal branch
1229 * @tc.type: FUNC
1230 * @tc.require:SR000GVIG3
1231 */
1232 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptAndDecrypt005, TestSize.Level1)
1233 {
1234 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptAndDecrypt005");
1235
1236 struct DlpBlob key = { 32, nullptr };
1237 key.data = g_key;
1238
1239 struct DlpCipherParam tagIv = { .iv = { .data = nullptr, .size = 16}};
1240 tagIv.iv.data = g_iv;
1241 struct DlpUsageSpec usage = {
1242 .mode = DLP_MODE_CTR,
1243 .algParam = &tagIv
1244 };
1245
1246 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1247 uint8_t enc[16] = {0};
1248 struct DlpBlob mIn = {
1249 .data = input,
1250 .size = 15
1251 };
1252 struct DlpBlob mEnc = {
1253 .data = enc,
1254 .size = 15
1255 };
1256
1257 // cipher ctx new failed when OpensslAesCipherInit
1258 DlpCMockCondition condition;
1259 condition.mockSequence = { true };
1260 SetMockConditions("EVP_CIPHER_CTX_new", condition);
1261 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncrypt(&key, &usage, &mIn, &mEnc));
1262 CleanMockConditions();
1263
1264 // EVP_aes_256_ctr return cipher failed when OpensslAesCipherInit
1265 condition.mockSequence = { true };
1266 SetMockConditions("EVP_aes_256_ctr", condition);
1267 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpOpensslAesEncrypt(&key, &usage, &mIn, &mEnc));
1268 CleanMockConditions();
1269
1270 // EVP_EncryptInit_ex return failed when OpensslAesCipherInit
1271 condition.mockSequence = { true };
1272 SetMockConditions("EVP_EncryptInit_ex", condition);
1273 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncrypt(&key, &usage, &mIn, &mEnc));
1274 CleanMockConditions();
1275 }
1276
1277 /**
1278 * @tc.name: DlpOpensslAesEncryptAndDecrypt006
1279 * @tc.desc: Dlp encrypt && decrypt openssl abnormal branch
1280 * @tc.type: FUNC
1281 * @tc.require:SR000GVIG3
1282 */
1283 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptAndDecrypt006, TestSize.Level1)
1284 {
1285 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptAndDecrypt006");
1286
1287 struct DlpBlob key = { 32, nullptr };
1288 key.data = g_key;
1289
1290 struct DlpCipherParam tagIv = { .iv = { .data = nullptr, .size = 16}};
1291 tagIv.iv.data = g_iv;
1292 struct DlpUsageSpec usage = {
1293 .mode = DLP_MODE_CTR,
1294 .algParam = &tagIv
1295 };
1296
1297 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1298 uint8_t enc[16] = {0};
1299 struct DlpBlob mIn = {
1300 .data = input,
1301 .size = 15
1302 };
1303 struct DlpBlob mEnc = {
1304 .data = enc,
1305 .size = 15
1306 };
1307
1308 // EVP_EncryptInit_ex first success and second failed when OpensslAesCipherInit
1309 DlpCMockCondition condition;
1310 condition.mockSequence = { false, true };
1311 SetMockConditions("EVP_EncryptInit_ex", condition);
1312 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncrypt(&key, &usage, &mIn, &mEnc));
1313 CleanMockConditions();
1314
1315 // EVP_CIPHER_CTX_set_padding failed when OpensslAesCipherInit
1316 condition.mockSequence = { true };
1317 SetMockConditions("EVP_CIPHER_CTX_set_padding", condition);
1318 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncrypt(&key, &usage, &mIn, &mEnc));
1319 CleanMockConditions();
1320
1321 // EVP_EncryptUpdate failed when OpensslAesCipherEncryptFinal
1322 condition.mockSequence = { true };
1323 SetMockConditions("EVP_EncryptUpdate", condition);
1324 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncrypt(&key, &usage, &mIn, &mEnc));
1325 CleanMockConditions();
1326
1327 // EVP_EncryptFinal_ex failed when OpensslAesCipherEncryptFinal
1328 condition.mockSequence = { true };
1329 SetMockConditions("EVP_EncryptFinal_ex", condition);
1330 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesEncrypt(&key, &usage, &mIn, &mEnc));
1331 CleanMockConditions();
1332 }
1333
1334 /**
1335 * @tc.name: DlpOpensslAesEncryptAndDecrypt007
1336 * @tc.desc: Dlp encrypt && decrypt openssl abnormal branch
1337 * @tc.type: FUNC
1338 * @tc.require:SR000GVIG3
1339 */
1340 HWTEST_F(DlpCryptTest, DlpOpensslAesEncryptAndDecrypt007, TestSize.Level1)
1341 {
1342 DLP_LOG_INFO(LABEL, "DlpOpensslAesEncryptAndDecrypt007");
1343 struct DlpBlob key = { 32, nullptr };
1344 key.data = g_key;
1345 struct DlpCipherParam tagIv = { .iv = { .data = nullptr, .size = 16}};
1346 tagIv.iv.data = g_iv;
1347 struct DlpUsageSpec usage = {
1348 .mode = DLP_MODE_CTR,
1349 .algParam = &tagIv
1350 };
1351 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1352 uint8_t enc[16] = {0};
1353 uint8_t dec[16] = {0};
1354 struct DlpBlob mIn = {
1355 .data = input,
1356 .size = 15
1357 };
1358 struct DlpBlob mEnc = {
1359 .data = enc,
1360 .size = 15
1361 };
1362 struct DlpBlob mDec = {
1363 .data = dec,
1364 .size = 15
1365 };
1366 DlpCMockCondition condition;
1367 // usage.mode is not DLP_MODE_CTR when DlpOpensslAesEncrypt
1368 CheckParams(&usage, &key, &mIn, &mEnc);
1369 key.size = 24;
1370 // OpensslAesCipherInit failed when DlpOpensslAesDecrypt
1371 condition.mockSequence = { true };
1372 SetMockConditions("EVP_CIPHER_CTX_new", condition);
1373 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesDecrypt(&key, &usage, &mEnc, &mDec));
1374 CleanMockConditions();
1375 // OpensslAesCipherEncryptFinal failed when DlpOpensslAesDecrypt
1376 condition.mockSequence = { true };
1377 SetMockConditions("EVP_DecryptUpdate", condition);
1378 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesDecrypt(&key, &usage, &mEnc, &mDec));
1379 CleanMockConditions();
1380 // EVP_DecryptFinal_ex failed when DlpOpensslAesDecrypt
1381 condition.mockSequence = { true };
1382 SetMockConditions("EVP_DecryptFinal_ex", condition);
1383 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslAesDecrypt(&key, &usage, &mEnc, &mDec));
1384 CleanMockConditions();
1385 // usage.mode is not DLP_MODE_CTR when DlpOpensslAesDecrypt
1386 usage.mode = 1000;
1387 ASSERT_EQ(DLP_PARSE_ERROR_OPERATION_UNSUPPORTED, DlpOpensslAesDecrypt(&key, &usage, &mEnc, &mDec));
1388 }
1389
1390 /**
1391 * @tc.name: DlpOpensslAesHalFreeCtx001
1392 * @tc.desc: free crypt ctx test
1393 * @tc.type: FUNC
1394 * @tc.require:SR000GVIG3
1395 */
1396 HWTEST_F(DlpCryptTest, DlpOpensslAesHalFreeCtx001, TestSize.Level1)
1397 {
1398 DLP_LOG_INFO(LABEL, "DlpOpensslAesHalFreeCtx001");
1399 void *ctx;
1400 struct DlpBlob key = { 32, nullptr };
1401 key.data = g_key;
1402 struct DlpCipherParam tagIv = { .iv = { .data = nullptr, .size = 16}};
1403 tagIv.iv.data = g_iv;
1404 struct DlpUsageSpec usage = {
1405 .mode = DLP_MODE_CTR,
1406 .algParam = &tagIv
1407 };
1408 ASSERT_EQ(DLP_OK, DlpOpensslAesEncryptInit(&ctx, &key, &usage));
1409
1410 // mode invalid
1411 struct DlpOpensslAesCtx* opensslAesCtx = static_cast<struct DlpOpensslAesCtx*>(ctx);
1412 opensslAesCtx->mode = 1000;
1413 DlpOpensslAesHalFreeCtx(&ctx);
1414 ASSERT_EQ(ctx, nullptr);
1415 }
1416
1417 /**
1418 * @tc.name: DlpOpensslAesHalFreeCtx002
1419 * @tc.desc: free crypt ctx test append null
1420 * @tc.type: FUNC
1421 * @tc.require:SR000GVIG3
1422 */
1423 HWTEST_F(DlpCryptTest, DlpOpensslAesHalFreeCtx002, TestSize.Level1)
1424 {
1425 DLP_LOG_INFO(LABEL, "DlpOpensslAesHalFreeCtx002");
1426 void *ctx;
1427 struct DlpBlob key = { 32, nullptr };
1428 key.data = g_key;
1429 struct DlpCipherParam tagIv = { .iv = { .data = nullptr, .size = 16}};
1430 tagIv.iv.data = g_iv;
1431 struct DlpUsageSpec usage = {
1432 .mode = DLP_MODE_CTR,
1433 .algParam = &tagIv
1434 };
1435 ASSERT_EQ(DLP_OK, DlpOpensslAesEncryptInit(&ctx, &key, &usage));
1436
1437 // append nullptr
1438 struct DlpOpensslAesCtx* opensslAesCtx = static_cast<struct DlpOpensslAesCtx*>(ctx);
1439 opensslAesCtx->append = nullptr;
1440 DlpOpensslAesHalFreeCtx(&ctx);
1441 ASSERT_EQ(ctx, nullptr);
1442 }
1443
1444 /**
1445 * @tc.name: GetOpensslAlg001
1446 * @tc.desc: get openssl invalid alg
1447 * @tc.type: FUNC
1448 * @tc.require:SR000GVIG3
1449 */
1450 HWTEST_F(DlpCryptTest, GetOpensslAlg001, TestSize.Level1)
1451 {
1452 DLP_LOG_INFO(LABEL, "GetOpensslAlg001");
1453 ASSERT_EQ(GetOpensslAlg(1000), nullptr);
1454 }
1455
1456 /**
1457 * @tc.name: DlpOpensslHash001
1458 * @tc.desc: HASH test
1459 * @tc.type: FUNC
1460 * @tc.require:SR000GVIG3
1461 */
1462 HWTEST_F(DlpCryptTest, DlpOpensslHash001, TestSize.Level1)
1463 {
1464 DLP_LOG_INFO(LABEL, "DlpOpensslHash001");
1465 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1466 uint8_t out[64] = {0};
1467 struct DlpBlob mIn = {
1468 .data = nullptr,
1469 .size = 15
1470 };
1471 mIn.data = input;
1472 struct DlpBlob mOut = {
1473 .data = nullptr,
1474 .size = 64
1475 };
1476 mOut.data = out;
1477 int ret;
1478
1479 ret = DlpOpensslHash(DLP_DIGEST_SHA256, &mIn, &mOut);
1480 cout << "sha256:";
1481 Dumpptr(out, 16);
1482 ASSERT_EQ(0, ret);
1483 mOut.size = 64;
1484 ret = DlpOpensslHash(DLP_DIGEST_SHA384, &mIn, &mOut);
1485 cout << "sha384:";
1486 Dumpptr(out, 16);
1487 ASSERT_EQ(0, ret);
1488 mOut.size = 64;
1489 ret = DlpOpensslHash(DLP_DIGEST_SHA512, &mIn, &mOut);
1490 cout << "sha512:";
1491 Dumpptr(out, 16);
1492 ASSERT_EQ(0, ret);
1493 }
1494
1495 /**
1496 * @tc.name: DlpOpensslHash002
1497 * @tc.desc: DlpOpensslHash with invalid alg
1498 * @tc.type: FUNC
1499 * @tc.require:SR000GVIG3
1500 */
1501 HWTEST_F(DlpCryptTest, DlpOpensslHash002, TestSize.Level1)
1502 {
1503 DLP_LOG_INFO(LABEL, "DlpOpensslHash002");
1504 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1505 uint8_t out[32] = {0};
1506 struct DlpBlob message = {15, input};
1507 struct DlpBlob hash = {32, out};
1508
1509 // alg = 0
1510 int32_t ret = DlpOpensslHash(DLP_DIGEST_NONE, &message, &hash);
1511 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1512
1513 // alg != DLP_DIGEST_SHA256 | DLP_DIGEST_SHA384 | DLP_DIGEST_SHA512
1514 ret = DlpOpensslHash(100, &message, &hash);
1515 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1516 }
1517
1518 /**
1519 * @tc.name: DlpOpensslHash003
1520 * @tc.desc: DlpOpensslHash with invalid message
1521 * @tc.type: FUNC
1522 * @tc.require:SR000GVIG3
1523 */
1524 HWTEST_F(DlpCryptTest, DlpOpensslHash003, TestSize.Level1)
1525 {
1526 DLP_LOG_INFO(LABEL, "DlpOpensslHash003");
1527 uint8_t out[64] = {0};
1528 struct DlpBlob hash = {64, out};
1529
1530 // message = nullptr
1531 int32_t ret = DlpOpensslHash(DLP_DIGEST_SHA512, nullptr, &hash);
1532 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1533 }
1534
1535 /**
1536 * @tc.name: DlpOpensslHash004
1537 * @tc.desc: DlpOpensslHash with invalid hash
1538 * @tc.type: FUNC
1539 * @tc.require:SR000GVIG3
1540 */
1541 HWTEST_F(DlpCryptTest, DlpOpensslHash004, TestSize.Level1)
1542 {
1543 DLP_LOG_INFO(LABEL, "DlpOpensslHash004");
1544 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1545 struct DlpBlob message = {15, input};
1546
1547 // hash = nullptr
1548 int32_t ret = DlpOpensslHash(DLP_DIGEST_SHA512, &message, nullptr);
1549 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1550 }
1551
1552 /**
1553 * @tc.name: DlpOpensslHash005
1554 * @tc.desc: DlpOpensslHash with hash len < alg len
1555 * @tc.type: FUNC
1556 * @tc.require:SR000GVIG3
1557 */
1558 HWTEST_F(DlpCryptTest, DlpOpensslHash005, TestSize.Level1)
1559 {
1560 DLP_LOG_INFO(LABEL, "DlpOpensslHash005");
1561 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1562 struct DlpBlob message = {15, input};
1563 uint8_t output[16] = {};
1564 struct DlpBlob hash = {16, output};
1565
1566 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpOpensslHash(DLP_DIGEST_SHA512, &message, &hash));
1567 }
1568
1569 /**
1570 * @tc.name: DlpOpensslHash006
1571 * @tc.desc: DlpOpensslHash with openssl abnormal branch
1572 * @tc.type: FUNC
1573 * @tc.require:SR000GVIG3
1574 */
1575 HWTEST_F(DlpCryptTest, DlpOpensslHash006, TestSize.Level1)
1576 {
1577 DLP_LOG_INFO(LABEL, "DlpOpensslHash006");
1578 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1579 struct DlpBlob message = {15, input};
1580 uint8_t output[16] = {};
1581 struct DlpBlob hash = {64, output};
1582
1583 // EVP_sha512 failed
1584 DlpCMockCondition condition;
1585 condition.mockSequence = { true };
1586 SetMockConditions("EVP_sha512", condition);
1587 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslHash(DLP_DIGEST_SHA512, &message, &hash));
1588 CleanMockConditions();
1589
1590 // EVP_Digest failed
1591 condition.mockSequence = { true };
1592 SetMockConditions("EVP_Digest", condition);
1593 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslHash(DLP_DIGEST_SHA512, &message, &hash));
1594 CleanMockConditions();
1595 }
1596
1597 /**
1598 * @tc.name: DlpOpensslHashInit001
1599 * @tc.desc: DlpOpensslHashInit with invalid cryptoCtx
1600 * @tc.type: FUNC
1601 * @tc.require:SR000GVIG3
1602 */
1603 HWTEST_F(DlpCryptTest, DlpOpensslHashInit001, TestSize.Level1)
1604 {
1605 DLP_LOG_INFO(LABEL, "DlpOpensslHashInit001");
1606
1607 // cryptoCtx = nullptr
1608 int32_t ret = DlpOpensslHashInit(nullptr, DLP_DIGEST_SHA256);
1609 EXPECT_EQ(DLP_PARSE_ERROR_DIGEST_INVALID, ret);
1610 }
1611
1612 /**
1613 * @tc.name: DlpOpensslHashInit002
1614 * @tc.desc: DlpOpensslHashInit with invalid alg
1615 * @tc.type: FUNC
1616 * @tc.require:SR000GVIG3
1617 */
1618 HWTEST_F(DlpCryptTest, DlpOpensslHashInit002, TestSize.Level1)
1619 {
1620 DLP_LOG_INFO(LABEL, "DlpOpensslHashInit002");
1621
1622 // alg = DLP_DIGEST_NONE
1623 void* ctx = nullptr;
1624 int32_t ret = DlpOpensslHashInit(&ctx, DLP_DIGEST_NONE);
1625 EXPECT_EQ(DLP_PARSE_ERROR_DIGEST_INVALID, ret);
1626
1627 // alg = 100
1628 ctx = nullptr;
1629 ret = DlpOpensslHashInit(&ctx, 100);
1630 EXPECT_EQ(DLP_PARSE_ERROR_DIGEST_INVALID, ret);
1631 }
1632
1633 /**
1634 * @tc.name: DlpOpensslHashInit003
1635 * @tc.desc: DlpOpensslHashInit with openssl abnormal branch
1636 * @tc.type: FUNC
1637 * @tc.require:SR000GVIG3
1638 */
1639 HWTEST_F(DlpCryptTest, DlpOpensslHashInit003, TestSize.Level1)
1640 {
1641 DLP_LOG_INFO(LABEL, "DlpOpensslHashInit003");
1642 void* ctx = nullptr;
1643
1644 // EVP_sha512 fail
1645 DlpCMockCondition condition;
1646 condition.mockSequence = { true };
1647 SetMockConditions("EVP_sha512", condition);
1648 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA512));
1649 CleanMockConditions();
1650
1651 // EVP_MD_CTX_new fail
1652 condition.mockSequence = { true };
1653 SetMockConditions("EVP_MD_CTX_new", condition);
1654 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA512));
1655 CleanMockConditions();
1656
1657 // EVP_DigestInit_ex fail
1658 condition.mockSequence = { true };
1659 SetMockConditions("EVP_DigestInit_ex", condition);
1660 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA512));
1661 CleanMockConditions();
1662 }
1663
1664 /**
1665 * @tc.name: DlpOpensslHashUpdate001
1666 * @tc.desc: DlpOpensslHashUpdate with invalid cryptoCtx
1667 * @tc.type: FUNC
1668 * @tc.require:SR000GVIG3
1669 */
1670 HWTEST_F(DlpCryptTest, DlpOpensslHashUpdate001, TestSize.Level1)
1671 {
1672 DLP_LOG_INFO(LABEL, "DlpOpensslHashUpdate001");
1673 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1674 struct DlpBlob message = {15, input};
1675
1676 // cryptoCtx = nullptr
1677 int32_t ret = DlpOpensslHashUpdate(nullptr, &message);
1678 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1679 }
1680
1681 /**
1682 * @tc.name: DlpOpensslHashUpdate002
1683 * @tc.desc: DlpOpensslHashUpdate with invalid message
1684 * @tc.type: FUNC
1685 * @tc.require:SR000GVIG3
1686 */
1687 HWTEST_F(DlpCryptTest, DlpOpensslHashUpdate002, TestSize.Level1)
1688 {
1689 DLP_LOG_INFO(LABEL, "DlpOpensslHashUpdate002");
1690 void* ctx = nullptr;
1691 int32_t ret = DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA256);
1692 ASSERT_EQ(0, ret);
1693
1694 // message = nullptr
1695 ret = DlpOpensslHashUpdate(ctx, nullptr);
1696 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1697 EVP_MD_CTX_free(reinterpret_cast<EVP_MD_CTX*>(ctx));
1698 }
1699
1700 /**
1701 * @tc.name: DlpOpensslHashUpdate003
1702 * @tc.desc: DlpOpensslHashUpdate with openssl abnormal barnch
1703 * @tc.type: FUNC
1704 * @tc.require:SR000GVIG3
1705 */
1706 HWTEST_F(DlpCryptTest, DlpOpensslHashUpdate003, TestSize.Level1)
1707 {
1708 DLP_LOG_INFO(LABEL, "DlpOpensslHashUpdate003");
1709 void* ctx = nullptr;
1710 int32_t ret = DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA256);
1711 ASSERT_EQ(0, ret);
1712
1713 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1714 struct DlpBlob msg1 = {15, input};
1715
1716 // EVP_DigestUpdate failed
1717 DlpCMockCondition condition;
1718 condition.mockSequence = { true };
1719 SetMockConditions("EVP_DigestUpdate", condition);
1720 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslHashUpdate(ctx, &msg1));
1721 CleanMockConditions();
1722 EVP_MD_CTX_free(reinterpret_cast<EVP_MD_CTX*>(ctx));
1723 }
1724
1725 /**
1726 * @tc.name: DlpOpensslHashFinal001
1727 * @tc.desc: DlpOpensslHashFinal with invalid cryptoCtx
1728 * @tc.type: FUNC
1729 * @tc.require:SR000GVIG3
1730 */
1731 HWTEST_F(DlpCryptTest, DlpOpensslHashFinal001, TestSize.Level1)
1732 {
1733 DLP_LOG_INFO(LABEL, "DlpOpensslHashFinal001");
1734 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1735 uint8_t out[64] = {0};
1736 struct DlpBlob message = {15, input};
1737 struct DlpBlob hash = {64, out};
1738
1739 // cryptoCtx = nullptr
1740 int32_t ret = DlpOpensslHashFinal(nullptr, &message, &hash);
1741 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1742 }
1743
1744 /**
1745 * @tc.name: DlpOpensslHashFinal002
1746 * @tc.desc: DlpOpensslHashFinal with invalid message
1747 * @tc.type: FUNC
1748 * @tc.require:SR000GVIG3
1749 */
1750 HWTEST_F(DlpCryptTest, DlpOpensslHashFinal002, TestSize.Level1)
1751 {
1752 DLP_LOG_INFO(LABEL, "DlpOpensslHashFinal002");
1753 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1754 uint8_t out[64] = {0};
1755 struct DlpBlob hash = {64, out};
1756 struct DlpBlob msg1 = {15, input};
1757 void* ctx = nullptr;
1758
1759 int32_t ret = DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA256);
1760 EXPECT_EQ(0, ret);
1761
1762 msg1.size = 1;
1763 int i = 0;
1764 while (i < 15) {
1765 ret = DlpOpensslHashUpdate(ctx, &msg1);
1766 EXPECT_EQ(0, ret);
1767 msg1.data = msg1.data + 1;
1768 i++;
1769 }
1770
1771 // message = nullptr
1772 ret = DlpOpensslHashFinal(&ctx, nullptr, &hash);
1773 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1774 EVP_MD_CTX_free(reinterpret_cast<EVP_MD_CTX*>(ctx));
1775 }
1776
1777 /**
1778 * @tc.name: DlpOpensslHashFinal003
1779 * @tc.desc: DlpOpensslHashFinal ok
1780 * @tc.type: FUNC
1781 * @tc.require:SR000GVIG3
1782 */
1783 HWTEST_F(DlpCryptTest, DlpOpensslHashFinal003, TestSize.Level1)
1784 {
1785 DLP_LOG_INFO(LABEL, "DlpOpensslHashFinal003");
1786 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1787 uint8_t out[64] = {0};
1788 struct DlpBlob hash = {64, out};
1789 struct DlpBlob msg1 = {15, input};
1790 void* ctx = nullptr;
1791
1792 int32_t ret = DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA256);
1793 EXPECT_EQ(0, ret);
1794
1795 msg1.size = 1;
1796 int i = 0;
1797 while (i < 15) {
1798 ret = DlpOpensslHashUpdate(ctx, &msg1);
1799 EXPECT_EQ(0, ret);
1800 msg1.data = msg1.data + 1;
1801 i++;
1802 }
1803
1804 ret = DlpOpensslHashFinal(&ctx, &msg1, &hash);
1805 EXPECT_EQ(DLP_OK, ret);
1806 EVP_MD_CTX_free(reinterpret_cast<EVP_MD_CTX*>(ctx));
1807 }
1808
1809 /**
1810 * @tc.name: DlpOpensslHashFinal004
1811 * @tc.desc: DlpOpensslHashFinal with invalid hash
1812 * @tc.type: FUNC
1813 * @tc.require:SR000GVIG3
1814 */
1815 HWTEST_F(DlpCryptTest, DlpOpensslHashFinal004, TestSize.Level1)
1816 {
1817 DLP_LOG_INFO(LABEL, "DlpOpensslHashFinal004");
1818 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1819 struct DlpBlob message = {15, input};
1820 struct DlpBlob msg1 = {15, input};
1821 void* ctx = nullptr;
1822
1823 int32_t ret = DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA256);
1824 EXPECT_EQ(0, ret);
1825
1826 msg1.size = 1;
1827 int i = 0;
1828 while (i < 15) {
1829 ret = DlpOpensslHashUpdate(ctx, &msg1);
1830 EXPECT_EQ(0, ret);
1831 msg1.data = msg1.data + 1;
1832 i++;
1833 }
1834
1835 // hash = nullptr
1836 ret = DlpOpensslHashFinal(&ctx, &message, nullptr);
1837 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
1838 EVP_MD_CTX_free(reinterpret_cast<EVP_MD_CTX*>(ctx));
1839 }
1840
1841 /**
1842 * @tc.name: DlpOpensslHashFinal005
1843 * @tc.desc: DlpOpensslHashFinal with openssl EVP_DigestUpdate fail
1844 * @tc.type: FUNC
1845 * @tc.require:SR000GVIG3
1846 */
1847 HWTEST_F(DlpCryptTest, DlpOpensslHashFinal005, TestSize.Level1)
1848 {
1849 DLP_LOG_INFO(LABEL, "DlpOpensslHashFinal005");
1850 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1851 uint8_t out[64] = {0};
1852 struct DlpBlob hash = {64, out};
1853 struct DlpBlob msg1 = {15, input};
1854 void* ctx = nullptr;
1855
1856 int32_t ret = DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA256);
1857 EXPECT_EQ(0, ret);
1858
1859 msg1.size = 1;
1860 int i = 0;
1861 while (i < 15) {
1862 ret = DlpOpensslHashUpdate(ctx, &msg1);
1863 EXPECT_EQ(0, ret);
1864 msg1.data = msg1.data + 1;
1865 i++;
1866 }
1867
1868 DlpCMockCondition condition;
1869 condition.mockSequence = { true };
1870 SetMockConditions("EVP_DigestUpdate", condition);
1871 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslHashFinal(&ctx, &msg1, &hash));
1872 CleanMockConditions();
1873
1874 EVP_MD_CTX_free(reinterpret_cast<EVP_MD_CTX*>(ctx));
1875 }
1876
1877 /**
1878 * @tc.name: DlpOpensslHashFinal006
1879 * @tc.desc: DlpOpensslHashFinal with openssl EVP_DigestFinal_ex fail
1880 * @tc.type: FUNC
1881 * @tc.require:SR000GVIG3
1882 */
1883 HWTEST_F(DlpCryptTest, DlpOpensslHashFinal006, TestSize.Level1)
1884 {
1885 DLP_LOG_INFO(LABEL, "DlpOpensslHashFinal006");
1886 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1887 uint8_t out[64] = {0};
1888 struct DlpBlob hash = {64, out};
1889 struct DlpBlob msg1 = {15, input};
1890 void* ctx = nullptr;
1891
1892 int32_t ret = DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA256);
1893 EXPECT_EQ(0, ret);
1894
1895 msg1.size = 1;
1896 int i = 0;
1897 while (i < 15) {
1898 ret = DlpOpensslHashUpdate(ctx, &msg1);
1899 EXPECT_EQ(0, ret);
1900 msg1.data = msg1.data + 1;
1901 i++;
1902 }
1903
1904 DlpCMockCondition condition;
1905 condition.mockSequence = { true };
1906 SetMockConditions("EVP_DigestFinal_ex", condition);
1907 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, DlpOpensslHashFinal(&ctx, &msg1, &hash));
1908 CleanMockConditions();
1909
1910 EVP_MD_CTX_free(reinterpret_cast<EVP_MD_CTX*>(ctx));
1911 }
1912
1913 /**
1914 * @tc.name: DlpOpensslHashFreeCtx001
1915 * @tc.desc: DlpOpensslHashFreeCtx with null
1916 * @tc.type: FUNC
1917 * @tc.require:SR000GVIG3
1918 */
1919 HWTEST_F(DlpCryptTest, DlpOpensslHashFreeCtx001, TestSize.Level1)
1920 {
1921 DLP_LOG_INFO(LABEL, "DlpOpensslHashFreeCtx001");
1922 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpOpensslHashFreeCtx(nullptr));
1923
1924 void *ctx = nullptr;
1925 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpOpensslHashFreeCtx(&ctx));
1926 }
1927
1928 /**
1929 * @tc.name: DlpOpensslHashFreeCtx002
1930 * @tc.desc: DlpOpensslHashFreeCtx with null
1931 * @tc.type: FUNC
1932 * @tc.require:SR000GVIG3
1933 */
1934 HWTEST_F(DlpCryptTest, DlpOpensslHashFreeCtx002, TestSize.Level1)
1935 {
1936 DLP_LOG_INFO(LABEL, "DlpOpensslHashFreeCtx002");
1937 void* ctx = nullptr;
1938 ASSERT_EQ(0, DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA256));
1939 ASSERT_EQ(DLP_OK, DlpOpensslHashFreeCtx(&ctx));
1940 }
1941
1942 /**
1943 * @tc.name: DlpOpensslHashTest001
1944 * @tc.desc: split hash test
1945 * @tc.type: FUNC
1946 * @tc.require:SR000GVIG3
1947 */
1948 HWTEST_F(DlpCryptTest, DlpOpensslHashTest001, TestSize.Level1)
1949 {
1950 DLP_LOG_INFO(LABEL, "DlpOpensslHashTest001");
1951 uint8_t input[16] = "aaaaaaaaaaaaaaa";
1952 uint8_t out[64] = {0};
1953 struct DlpBlob mIn = {
1954 .data = nullptr,
1955 .size = 15
1956 };
1957 mIn.data = input;
1958 struct DlpBlob mOut = {
1959 .data = nullptr,
1960 .size = 15
1961 };
1962 mOut.data = out;
1963 struct DlpBlob mNull = {
1964 .data = nullptr,
1965 .size = 0
1966 };
1967 int i = 0;
1968 int ret;
1969 void *ctx;
1970
1971 ret = DlpOpensslHashInit(&ctx, DLP_DIGEST_SHA256);
1972 ASSERT_EQ(0, ret);
1973
1974 mIn.size = 1;
1975 while (i < 15) {
1976 ret = DlpOpensslHashUpdate(ctx, &mIn);
1977 ASSERT_EQ(0, ret);
1978 mIn.data = mIn.data + 1;
1979 i++;
1980 }
1981 ret = DlpOpensslHashFinal(&ctx, &mNull, &mOut);
1982 ASSERT_EQ(0, ret);
1983 DlpOpensslHashFreeCtx(&ctx);
1984
1985 cout << "sha256sum:";
1986 Dumpptr(out, 16);
1987 ASSERT_EQ(0, ret);
1988 }
1989
1990 /**
1991 * @tc.name: DlpOpensslGenerateRandomKey001
1992 * @tc.desc: random generate test
1993 * @tc.type: FUNC
1994 * @tc.require:SR000GVIG3
1995 */
1996 HWTEST_F(DlpCryptTest, DlpOpensslGenerateRandomKey001, TestSize.Level1)
1997 {
1998 DLP_LOG_INFO(LABEL, "DlpOpensslGenerateRandomKey001");
1999 int ret = 0;
2000 struct DlpBlob mIn = {
2001 .data = nullptr,
2002 .size = 32
2003 };
2004
2005 ret = DlpOpensslGenerateRandomKey(DLP_AES_KEY_SIZE_256, &mIn);
2006 ASSERT_EQ(0, ret);
2007 cout << "random key:";
2008 Dumpptr(mIn.data, 16);
2009 free(mIn.data);
2010 ret = DlpOpensslGenerateRandomKey(DLP_AES_KEY_SIZE_192, &mIn);
2011 ASSERT_EQ(0, ret);
2012 cout << "random key:";
2013 Dumpptr(mIn.data, 16);
2014 free(mIn.data);
2015 ret = DlpOpensslGenerateRandomKey(DLP_AES_KEY_SIZE_128, &mIn);
2016 ASSERT_EQ(0, ret);
2017 cout << "random key:";
2018 Dumpptr(mIn.data, 16);
2019 free(mIn.data);
2020 }
2021
2022 /**
2023 * @tc.name: DlpOpensslGenerateRandomKey002
2024 * @tc.desc: random generate test with invalid keySize
2025 * @tc.type: FUNC
2026 * @tc.require:SR000GVIG3
2027 */
2028 HWTEST_F(DlpCryptTest, DlpOpensslGenerateRandomKey002, TestSize.Level1)
2029 {
2030 DLP_LOG_INFO(LABEL, "DlpOpensslGenerateRandomKey002");
2031 struct DlpBlob key = {32, nullptr};
2032 int32_t ret = DlpOpensslGenerateRandomKey(1, &key);
2033 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
2034 }
2035
2036 /**
2037 * @tc.name: DlpOpensslGenerateRandomKey003
2038 * @tc.desc: random generate test with invalid key
2039 * @tc.type: FUNC
2040 * @tc.require:SR000GVIG3
2041 */
2042 HWTEST_F(DlpCryptTest, DlpOpensslGenerateRandomKey003, TestSize.Level1)
2043 {
2044 DLP_LOG_INFO(LABEL, "DlpOpensslGenerateRandomKey003");
2045
2046 // key = nullptr
2047 int32_t ret = DlpOpensslGenerateRandomKey(DLP_AES_KEY_SIZE_256, nullptr);
2048 EXPECT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, ret);
2049 }
2050
2051 /**
2052 * @tc.name: DlpOpensslGenerateRandomKey004
2053 * @tc.desc: random generate test when RAND_bytes return null
2054 * @tc.type: FUNC
2055 * @tc.require:SR000GVIG3
2056 */
2057 HWTEST_F(DlpCryptTest, DlpOpensslGenerateRandomKey004, TestSize.Level1)
2058 {
2059 DLP_LOG_INFO(LABEL, "DlpOpensslGenerateRandomKey004");
2060
2061 struct DlpBlob mIn = {
2062 .data = nullptr,
2063 .size = 32
2064 };
2065
2066 DlpCMockCondition condition;
2067 condition.mockSequence = { true }; // first call return failed
2068 SetMockConditions("RAND_bytes", condition);
2069 int32_t ret = DlpOpensslGenerateRandomKey(DLP_AES_KEY_SIZE_256, &mIn);
2070 CleanMockConditions();
2071 ASSERT_EQ(DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, ret);
2072 }
2073
2074 /**
2075 * @tc.name: DlpCtrModeIncreaeIvCounter001
2076 * @tc.desc: random generate test when RAND_bytes return null
2077 * @tc.type: FUNC
2078 * @tc.require:SR000GVIG3
2079 */
2080 HWTEST_F(DlpCryptTest, DlpCtrModeIncreaeIvCounter001, TestSize.Level1)
2081 {
2082 DLP_LOG_INFO(LABEL, "DlpCtrModeIncreaeIvCounter001");
2083
2084 struct DlpBlob mIn = {
2085 .data = nullptr,
2086 .size = 8
2087 };
2088
2089 // data nullptr
2090 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpCtrModeIncreaeIvCounter(mIn, 0));
2091
2092 // size 0
2093 uint8_t ivData[8] = {0};
2094 mIn.data = ivData;
2095 mIn.size = 0;
2096 ASSERT_EQ(DLP_PARSE_ERROR_VALUE_INVALID, DlpCtrModeIncreaeIvCounter(mIn, 0));
2097
2098 // valid data
2099 mIn.data[7] = 0xff;
2100 mIn.size = 8;
2101 ASSERT_EQ(DLP_OK, DlpCtrModeIncreaeIvCounter(mIn, 1));
2102 ASSERT_EQ(mIn.data[7], 0);
2103 ASSERT_EQ(mIn.data[6], 1);
2104 }
2105
2106