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