1 /*
2 * Copyright (c) 2021-2022 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 <securec.h>
17 #include <string>
18 #include <memory>
19
20 #include <gtest/gtest.h>
21
22 #include "file_ex.h"
23 #include "hks_ability.h"
24 #include "hks_crypto_hal.h"
25 #include "hks_crypto_hal_common.h"
26 #include "hks_mem.h"
27
28 using namespace testing::ext;
29 namespace OHOS {
30 namespace Security {
31 namespace Huks {
32 namespace UnitTest {
33 namespace {
34 struct TestCaseParams {
35 HksUsageSpec usageSpec = {0};
36 std::string keyData;
37 std::string hexData;
38 HksStageType runStage = HksStageType::HKS_STAGE_THREE;
39
40 HksErrorCode decryptResult = HksErrorCode::HKS_SUCCESS;
41 };
42 struct TestCaseParamsForGcm {
43 std::string keyData;
44 std::string hexData;
45 std::string tagDec;
46 HksStageType runStage = HksStageType::HKS_STAGE_THREE;
47
48 HksErrorCode decryptResult = HksErrorCode::HKS_SUCCESS;
49 };
50
51 const uint32_t IV_SIZE = 16;
52 uint8_t IV[IV_SIZE] = {0};
53 HksCipherParam TAG_IV = { .iv = { .size = IV_SIZE, .data = IV } };
54
55 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_001_PARAMS = {
56 .usageSpec = {
57 .algType = HKS_ALG_AES,
58 .mode = HKS_MODE_CBC,
59 .padding = HKS_PADDING_NONE,
60 .digest = HKS_DIGEST_NONE,
61 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
62 .algParam = &TAG_IV,
63 },
64 .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
65 .hexData = "2665c033ca1d760d7fcfffce8eb09356a6a6e508584af3faf82fcce81b758934",
66
67 .decryptResult = HKS_SUCCESS,
68 };
69
70 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_002_PARAMS = {
71 .usageSpec = {
72 .algType = HKS_ALG_AES,
73 .mode = HKS_MODE_CBC,
74 .padding = HKS_PADDING_PKCS7,
75 .digest = HKS_DIGEST_NONE,
76 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
77 .algParam = &TAG_IV,
78 },
79 .keyData = "6b6579306b6579306b6579306b657930",
80 .hexData = "a043f74ce2620fc939811e9a949e9f0576c60fb964670ed6e626260f7e6d972aca0d0aeff876a8f03fd8ed8b91ff3f9a",
81
82 .decryptResult = HKS_SUCCESS,
83 };
84
85 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_003_PARAMS = {
86 .usageSpec = {
87 .algType = HKS_ALG_AES,
88 .mode = HKS_MODE_CTR,
89 .padding = HKS_PADDING_NONE,
90 .digest = HKS_DIGEST_NONE,
91 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
92 .algParam = &TAG_IV,
93 },
94 .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
95 .hexData = "2665c033ca1d760d7fcfffce8eb09356a6a6e508584af3faf82fcce81b758934",
96
97 .decryptResult = HKS_SUCCESS,
98 };
99
100 #ifdef HKS_UNTRUSTED_RUNNING_ENV
101 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_004_PARAMS = {
102 .usageSpec = {
103 .algType = HKS_ALG_AES,
104 .mode = HKS_MODE_ECB,
105 .padding = HKS_PADDING_NONE,
106 .digest = HKS_DIGEST_NONE,
107 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
108 .algParam = nullptr,
109 },
110 .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
111 .hexData = "2665c033ca1d760d7fcfffce8eb09356",
112
113 .decryptResult = HKS_SUCCESS,
114 };
115
116 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_005_PARAMS = {
117 .usageSpec = {
118 .algType = HKS_ALG_AES,
119 .mode = HKS_MODE_ECB,
120 .padding = HKS_PADDING_PKCS7,
121 .digest = HKS_DIGEST_NONE,
122 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
123 .algParam = nullptr,
124 },
125 .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
126 .hexData = "2665c033ca1d760d7fcfffce8eb0935670f5531be24753f04e3200829ea2fd60",
127 #if defined(_USE_OPENSSL_)
128 .decryptResult = HKS_SUCCESS,
129 #endif
130 #if defined(_USE_MBEDTLS_)
131 .decryptResult = HKS_ERROR_NOT_SUPPORTED,
132 #endif
133 };
134 #endif
135
136 const TestCaseParamsForGcm HKS_CRYPTO_HAL_AES_DECRYPT_006_PARAMS = {
137 .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
138 .hexData = "fd692103d931c663a0371bd250dd883aed48379774bfba64327cc4a3ea19afae",
139 .tagDec = "43a345ff5f3af4bb383f999393949acc",
140
141 .decryptResult = HKS_SUCCESS,
142 };
143
144 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_007_PARAMS = {
145 .usageSpec = {
146 .algType = HKS_ALG_AES,
147 .mode = HKS_MODE_CBC,
148 .padding = HKS_PADDING_NONE,
149 .digest = HKS_DIGEST_NONE,
150 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
151 .algParam = &TAG_IV,
152 },
153 .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
154 .hexData = "6b5d0d7ac2df878c338f085edf3431116b5d0d7ac2df878c338f085edf343111",
155
156 .decryptResult = HKS_SUCCESS,
157 };
158
159 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_008_PARAMS = {
160 .usageSpec = {
161 .algType = HKS_ALG_AES,
162 .mode = HKS_MODE_CBC,
163 .padding = HKS_PADDING_PKCS7,
164 .digest = HKS_DIGEST_NONE,
165 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
166 .algParam = &TAG_IV,
167 },
168 .keyData = "6b6579306b6579306b6579306b6579306b6579306b657930",
169 .hexData = "7897f888bda5244c049da27f1533dc80accf7a0c8a9169fa64779d1f34be146dcb0f793048dee9efaa032c7901b07b64",
170
171 .decryptResult = HKS_SUCCESS,
172 };
173
174 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_009_PARAMS = {
175 .usageSpec = {
176 .algType = HKS_ALG_AES,
177 .mode = HKS_MODE_CTR,
178 .padding = HKS_PADDING_NONE,
179 .digest = HKS_DIGEST_NONE,
180 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
181 .algParam = &TAG_IV,
182 },
183 .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
184 .hexData = "6b5d0d7ac2df878c338f085edf3431116b5d0d7ac2df878c338f085edf343111",
185
186 .decryptResult = HKS_SUCCESS,
187 };
188
189 #ifdef HKS_UNTRUSTED_RUNNING_ENV
190 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_010_PARAMS = {
191 .usageSpec = {
192 .algType = HKS_ALG_AES,
193 .mode = HKS_MODE_ECB,
194 .padding = HKS_PADDING_NONE,
195 .digest = HKS_DIGEST_NONE,
196 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
197 .algParam = nullptr,
198 },
199 .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
200 .hexData = "6b5d0d7ac2df878c338f085edf343111",
201
202 .decryptResult = HKS_SUCCESS,
203 };
204
205 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_011_PARAMS = {
206 .usageSpec = {
207 .algType = HKS_ALG_AES,
208 .mode = HKS_MODE_ECB,
209 .padding = HKS_PADDING_PKCS7,
210 .digest = HKS_DIGEST_NONE,
211 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
212 .algParam = nullptr,
213 },
214 .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
215 .hexData = "6b5d0d7ac2df878c338f085edf343111cf0afb8fc67acf62db781f324ecc361c",
216 #if defined(_USE_OPENSSL_)
217 .decryptResult = HKS_SUCCESS,
218 #endif
219 #if defined(_USE_MBEDTLS_)
220 .decryptResult = HKS_ERROR_NOT_SUPPORTED,
221 #endif
222 };
223 #endif
224
225 const TestCaseParamsForGcm HKS_CRYPTO_HAL_AES_DECRYPT_012_PARAMS = {
226 .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
227 .hexData = "06c34934467ad390f5f54410ac20c875feda920d514c3e43819ce16e1e2e3335",
228 .tagDec = "b3ad99cd7951405f1eeefb4e54783f17",
229
230 .decryptResult = HKS_SUCCESS,
231 };
232
233 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_013_PARAMS = {
234 .usageSpec = {
235 .algType = HKS_ALG_AES,
236 .mode = HKS_MODE_CBC,
237 .padding = HKS_PADDING_NONE,
238 .digest = HKS_DIGEST_NONE,
239 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
240 .algParam = &TAG_IV,
241 },
242 .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f",
243 .hexData = "f905f3936288181cb1d3931ab26c0314056d1521dc8549013a9b829bebedc71b",
244
245 .decryptResult = HKS_SUCCESS,
246 };
247
248 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_014_PARAMS = {
249 .usageSpec = {
250 .algType = HKS_ALG_AES,
251 .mode = HKS_MODE_CBC,
252 .padding = HKS_PADDING_PKCS7,
253 .digest = HKS_DIGEST_NONE,
254 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
255 .algParam = &TAG_IV,
256 },
257 .keyData = "6b6579306b6579306b6579306b6579306b6579306b6579306b6579306b657930",
258 .hexData = "acec21f1488248cdcf6f24a15124b1a68e401efd146cd944fabd84081b76dacf89989a52f8fc1e31dacb820ec8102365",
259
260 .decryptResult = HKS_SUCCESS,
261 };
262
263 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_015_PARAMS = {
264 .usageSpec = {
265 .algType = HKS_ALG_AES,
266 .mode = HKS_MODE_CTR,
267 .padding = HKS_PADDING_NONE,
268 .digest = HKS_DIGEST_NONE,
269 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
270 .algParam = &TAG_IV,
271 },
272 .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f",
273 .hexData = "f905f3936288181cb1d3931ab26c0314056d1521dc8549013a9b829bebedc71b",
274
275 .decryptResult = HKS_SUCCESS,
276 };
277
278 #ifdef HKS_UNTRUSTED_RUNNING_ENV
279 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_016_PARAMS = {
280 .usageSpec = {
281 .algType = HKS_ALG_AES,
282 .mode = HKS_MODE_ECB,
283 .padding = HKS_PADDING_NONE,
284 .digest = HKS_DIGEST_NONE,
285 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
286 .algParam = nullptr,
287 },
288 .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f",
289 .hexData = "f905f3936288181cb1d3931ab26c0314",
290
291 .decryptResult = HKS_SUCCESS,
292 };
293
294 const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_017_PARAMS = {
295 .usageSpec = {
296 .algType = HKS_ALG_AES,
297 .mode = HKS_MODE_ECB,
298 .padding = HKS_PADDING_PKCS7,
299 .digest = HKS_DIGEST_NONE,
300 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
301 .algParam = nullptr,
302 },
303 .keyData = "6b6579306b6579306b6579306b6579306b6579306b6579306b6579306b657930",
304 .hexData = "776a9f622d0978f89fff5c61ae5d4693776a9f622d0978f89fff5c61ae5d469379ea9dc7d7419ec0ea457aa041e1007a",
305 #if defined(_USE_OPENSSL_)
306 .decryptResult = HKS_SUCCESS,
307 #endif
308 #if defined(_USE_MBEDTLS_)
309 .decryptResult = HKS_ERROR_NOT_SUPPORTED,
310 #endif
311 };
312 #endif
313
314 const TestCaseParamsForGcm HKS_CRYPTO_HAL_AES_DECRYPT_018_PARAMS = {
315 .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f",
316 .hexData = "da047651955c64daa5cac9b0082f1567235e682041061fef12f896ba83bb1fde",
317 .tagDec = "35a956a070d5ed7472a9b66165bcada7",
318
319 .decryptResult = HKS_SUCCESS,
320 };
321 } // namespace
322
323 class HksCryptoHalAesDecrypt : public HksCryptoHalCommon, public testing::Test {
324 public:
325 static void SetUpTestCase(void);
326 static void TearDownTestCase(void);
327 void SetUp();
328 void TearDown();
329 protected:
RunTestCase(const TestCaseParams & testCaseParams) const330 void RunTestCase(const TestCaseParams &testCaseParams) const
331 {
332 uint32_t keyLen = testCaseParams.keyData.length() / HKS_COUNT_OF_HALF;
333 HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) };
334 ASSERT_EQ(key.data == nullptr, false) << "key malloc failed.";
335 for (uint32_t ii = 0; ii < keyLen; ii++) {
336 key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[HKS_COUNT_OF_HALF * ii]);
337 }
338
339 uint32_t inLen = testCaseParams.hexData.length() / HKS_COUNT_OF_HALF;
340 HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
341 uint32_t outLen = inLen;
342 if (testCaseParams.usageSpec.padding == HKS_PADDING_PKCS7) {
343 outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT;
344 }
345
346 ASSERT_EQ(message.data == nullptr, false) << "message malloc failed.";
347 for (uint32_t ii = 0; ii < inLen; ii++) {
348 message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[HKS_COUNT_OF_HALF * ii]);
349 }
350 HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) };
351 ASSERT_EQ(cipherText.data == nullptr, false) << "cipherText malloc failed.";
352 if (testCaseParams.runStage == HksStageType::HKS_STAGE_THREE) {
353 HksBlob tmpTagAead = { .size = 0, .data = nullptr };
354 RunTestAesDecrypt(&key, testCaseParams, &message, &cipherText, &tmpTagAead);
355 } else {
356 EXPECT_EQ(HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &message, &cipherText),
357 testCaseParams.decryptResult);
358 }
359
360 HKS_FREE(key.data);
361 HKS_FREE(message.data);
362 HKS_FREE(cipherText.data);
363 }
364
RunTestAesDecrypt(struct HksBlob * key,const TestCaseParams & testCaseParams,struct HksBlob * decryptMsg,struct HksBlob * decryptOut,struct HksBlob * tagAead) const365 void RunTestAesDecrypt(struct HksBlob *key, const TestCaseParams &testCaseParams, struct HksBlob *decryptMsg,
366 struct HksBlob *decryptOut, struct HksBlob *tagAead) const
367 {
368 void* decryptCtx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
369 ASSERT_EQ(decryptCtx == nullptr, false) << "decryptCtx malloc failed.";
370 EXPECT_EQ(HksCryptoHalDecryptInit(key, &testCaseParams.usageSpec, &decryptCtx), testCaseParams.decryptResult);
371 if (testCaseParams.decryptResult != HKS_SUCCESS) {
372 return;
373 }
374 uint32_t decrytopoint = 0;
375 uint32_t decrytoinLen = decryptMsg->size;
376
377 if (decrytoinLen > HKS_UPDATE_DATA_MAX) {
378 HksBlob messageUpdate = { .size = HKS_UPDATE_DATA_MAX, .data = (uint8_t *)HksMalloc(HKS_UPDATE_DATA_MAX) };
379 HksBlob out = { .size = decrytoinLen, .data = (uint8_t *)HksMalloc(decrytoinLen) };
380 ASSERT_EQ(messageUpdate.data == nullptr, false) << "messageUpdate malloc failed.";
381 ASSERT_EQ(out.data == nullptr, false) << "out malloc failed.";
382 while (decrytopoint < decrytoinLen - HKS_UPDATE_DATA_MAX) {
383 EXPECT_EQ(memcpy_s(messageUpdate.data, messageUpdate.size, (decryptMsg->data + decrytopoint),
384 HKS_UPDATE_DATA_MAX), EOK) << "memcpy fail";
385 EXPECT_EQ(HksCryptoHalDecryptUpdate(&messageUpdate, decryptCtx, &out,
386 testCaseParams.usageSpec.algType), testCaseParams.decryptResult);
387 decrytopoint = decrytopoint + HKS_UPDATE_DATA_MAX;
388 }
389 HKS_FREE(out.data);
390 HKS_FREE(messageUpdate.data);
391
392 uint32_t lastLen = decrytoinLen - decrytopoint;
393 HksBlob messageLast = { .size = lastLen, .data = (uint8_t *)HksMalloc(lastLen) };
394 ASSERT_EQ(messageLast.data == nullptr, false) << "messageLast malloc failed.";
395 (void)memcpy_s(messageLast.data, lastLen, (decryptMsg->data + decrytopoint), lastLen);
396 HksBlob outLast = { .size = lastLen, .data = (uint8_t *)HksMalloc(lastLen + HKS_PADDING_SUPPLENMENT) };
397 ASSERT_EQ(outLast.data == nullptr, false) << "outLast malloc failed.";
398 EXPECT_EQ(HksCryptoHalDecryptFinal(&messageLast, &decryptCtx, &outLast, tagAead,
399 testCaseParams.usageSpec.algType), testCaseParams.decryptResult) << "HksCryptoHalEncryptFinal failed.";
400 HKS_FREE(messageLast.data);
401 HKS_FREE(outLast.data);
402 } else {
403 HksBlob out = { .size = decrytoinLen, .data = (uint8_t *)HksMalloc(decrytoinLen) };
404 ASSERT_EQ(out.data == nullptr, false) << "out malloc failed.";
405 EXPECT_EQ(HksCryptoHalDecryptUpdate(decryptMsg, decryptCtx, &out,
406 testCaseParams.usageSpec.algType), testCaseParams.decryptResult);
407
408 HksBlob deMessageLast = { .size = 0, .data = nullptr };
409 EXPECT_EQ(HksCryptoHalDecryptFinal(&deMessageLast, &decryptCtx, decryptOut, tagAead,
410 testCaseParams.usageSpec.algType), testCaseParams.decryptResult);
411
412 HKS_FREE(out.data);
413 }
414 }
415
RunTestAesGcmDecrypt(struct HksBlob * key,const HksUsageSpec * usageSpec,struct HksBlob * decryptMsg,struct HksBlob * decryptOut,struct HksBlob * tagAead) const416 void RunTestAesGcmDecrypt(struct HksBlob *key, const HksUsageSpec *usageSpec, struct HksBlob *decryptMsg,
417 struct HksBlob *decryptOut, struct HksBlob *tagAead) const
418 {
419 void* decryptCtx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
420 ASSERT_EQ(decryptCtx == nullptr, false) << "decryptCtx malloc failed.";
421 EXPECT_EQ(HksCryptoHalDecryptInit(key, usageSpec, &decryptCtx), HKS_SUCCESS);
422
423 uint32_t decrytopoint = 0;
424 uint32_t decrytoinLen = decryptMsg->size;
425
426 if (decrytoinLen > HKS_UPDATE_DATA_MAX) {
427 HksBlob messageUpdate = { .size = HKS_UPDATE_DATA_MAX, .data = (uint8_t *)HksMalloc(HKS_UPDATE_DATA_MAX) };
428 HksBlob out = { .size = decrytoinLen, .data = (uint8_t *)HksMalloc(decrytoinLen) };
429 ASSERT_EQ(messageUpdate.data == nullptr, false) << "messageUpdate malloc failed.";
430 ASSERT_EQ(out.data == nullptr, false) << "out malloc failed.";
431 while (decrytopoint < decrytoinLen - HKS_UPDATE_DATA_MAX) {
432 EXPECT_EQ(memcpy_s(messageUpdate.data, messageUpdate.size, (decryptMsg->data + decrytopoint),
433 HKS_UPDATE_DATA_MAX), EOK) << "memcpy fail";
434 EXPECT_EQ(HksCryptoHalDecryptUpdate(&messageUpdate, decryptCtx, &out, usageSpec->algType), HKS_SUCCESS);
435 decrytopoint = decrytopoint + HKS_UPDATE_DATA_MAX;
436 }
437 HKS_FREE(out.data);
438 HKS_FREE(messageUpdate.data);
439
440 uint32_t lastLen = decrytoinLen - decrytopoint;
441 HksBlob messageLast = { .size = lastLen, .data = (uint8_t *)HksMalloc(lastLen) };
442 ASSERT_EQ(messageLast.data == nullptr, false) << "messageLast malloc failed.";
443 (void)memcpy_s(messageLast.data, lastLen, (decryptMsg->data + decrytopoint), lastLen);
444 HksBlob outLast = { .size = lastLen, .data = (uint8_t *)HksMalloc(lastLen + HKS_PADDING_SUPPLENMENT) };
445 ASSERT_EQ(outLast.data == nullptr, false) << "outLast malloc failed.";
446 EXPECT_EQ(HksCryptoHalDecryptFinal(&messageLast, &decryptCtx, &outLast, tagAead,
447 usageSpec->algType), HKS_SUCCESS) << "HksCryptoHalEncryptFinal failed.";
448 HKS_FREE(messageLast.data);
449 HKS_FREE(outLast.data);
450 } else {
451 HksBlob out = { .size = decrytoinLen, .data = (uint8_t *)HksMalloc(decrytoinLen) };
452 ASSERT_EQ(out.data == nullptr, false) << "out malloc failed.";
453 EXPECT_EQ(HksCryptoHalDecryptUpdate(decryptMsg, decryptCtx, &out, usageSpec->algType), HKS_SUCCESS);
454
455 HksBlob deMessageLast = { .size = 0, .data = nullptr };
456 EXPECT_EQ(HksCryptoHalDecryptFinal(&deMessageLast, &decryptCtx, decryptOut, tagAead,
457 usageSpec->algType), HKS_SUCCESS);
458
459 HKS_FREE(out.data);
460 }
461 }
462
GcmRunTestCase(const TestCaseParamsForGcm & testCaseParamsForGcm)463 void GcmRunTestCase(const TestCaseParamsForGcm &testCaseParamsForGcm)
464 {
465 uint32_t keyLen = testCaseParamsForGcm.keyData.length() / HKS_COUNT_OF_HALF;
466 HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) };
467 ASSERT_EQ(key.data == nullptr, false) << "key malloc failed.";
468 for (uint32_t ii = 0; ii < keyLen; ii++) {
469 key.data[ii] = ReadHex((const uint8_t *)&testCaseParamsForGcm.keyData[HKS_COUNT_OF_HALF * ii]);
470 }
471 uint32_t inLen = testCaseParamsForGcm.hexData.length() / HKS_COUNT_OF_HALF;
472 uint32_t outLen = inLen;
473 HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
474 ASSERT_EQ(message.data == nullptr, false) << "message malloc failed.";
475 for (uint32_t ii = 0; ii < inLen; ii++) {
476 message.data[ii] = ReadHex((const uint8_t *)&testCaseParamsForGcm.hexData[HKS_COUNT_OF_HALF * ii]);
477 }
478 HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) };
479 uint32_t tagDecSize = testCaseParamsForGcm.tagDec.length() / HKS_COUNT_OF_HALF;
480 HksBlob tagDecBlob = { .size = tagDecSize, .data = (uint8_t *)HksMalloc(tagDecSize) };
481 ASSERT_EQ(cipherText.data == nullptr, false) << "cipherText malloc failed.";
482 ASSERT_EQ(tagDecBlob.data == nullptr, false) << "tagDecBlob malloc failed.";
483 for (uint32_t ii = 0; ii < tagDecSize; ii++) {
484 tagDecBlob.data[ii] = ReadHex((const uint8_t *)&testCaseParamsForGcm.tagDec[HKS_COUNT_OF_HALF * ii]);
485 }
486 HksAeadParam AEAD_PARAM = {
487 .nonce = { .size = IV_SIZE, .data = IV },
488 .aad = { .size = 0, .data = nullptr },
489 .tagDec = tagDecBlob,
490 .payloadLen = 0,
491 };
492 HksUsageSpec usageSpec = {
493 .algType = HKS_ALG_AES,
494 .mode = HKS_MODE_GCM,
495 .padding = HKS_PADDING_NONE,
496 .digest = HKS_DIGEST_NONE,
497 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
498 .algParam = &AEAD_PARAM,
499 };
500
501 if (testCaseParamsForGcm.runStage == HksStageType::HKS_STAGE_THREE) {
502 RunTestAesGcmDecrypt(&key, &usageSpec, &message, &cipherText, &tagDecBlob);
503 } else {
504 EXPECT_EQ(HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText), testCaseParamsForGcm.decryptResult);
505 }
506
507 HKS_FREE(key.data);
508 HKS_FREE(message.data);
509 HKS_FREE(cipherText.data);
510 HKS_FREE(tagDecBlob.data);
511 }
512 };
513
SetUpTestCase(void)514 void HksCryptoHalAesDecrypt::SetUpTestCase(void)
515 {
516 }
517
TearDownTestCase(void)518 void HksCryptoHalAesDecrypt::TearDownTestCase(void)
519 {
520 }
521
SetUp()522 void HksCryptoHalAesDecrypt::SetUp()
523 {
524 EXPECT_EQ(HksCryptoAbilityInit(), 0);
525 }
526
TearDown()527 void HksCryptoHalAesDecrypt::TearDown()
528 {
529 }
530
531 /**
532 * @tc.number : HksCryptoHalAesDecrypt_001
533 * @tc.name : HksCryptoHalAesDecrypt_001
534 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CBC-NOPADDING key.
535 */
536 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_001, Function | SmallTest | Level0)
537 {
538 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_001_PARAMS);
539 }
540
541 /**
542 * @tc.number : HksCryptoHalAesDecrypt_002
543 * @tc.name : HksCryptoHalAesDecrypt_002
544 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CBC-PKCS7PADDING key.
545 */
546 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_002, Function | SmallTest | Level0)
547 {
548 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_002_PARAMS);
549 }
550
551 /**
552 * @tc.number : HksCryptoHalAesDecrypt_003
553 * @tc.name : HksCryptoHalAesDecrypt_003
554 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CTR-NOPADDING key.
555 */
556 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_003, Function | SmallTest | Level0)
557 {
558 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_003_PARAMS);
559 }
560
561 #ifdef HKS_UNTRUSTED_RUNNING_ENV
562 /**
563 * @tc.number : HksCryptoHalAesDecrypt_004
564 * @tc.name : HksCryptoHalAesDecrypt_004
565 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-ECB-NOPADDING key.
566 */
567 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_004, Function | SmallTest | Level0)
568 {
569 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_004_PARAMS);
570 }
571
572 /**
573 * @tc.number : HksCryptoHalAesDecrypt_005
574 * @tc.name : HksCryptoHalAesDecrypt_005
575 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-ECB-PKCS7PADDING key.
576 */
577 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_005, Function | SmallTest | Level0)
578 {
579 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_005_PARAMS);
580 }
581
582 /**
583 * @tc.number : HksCryptoHalAesDecrypt_010
584 * @tc.name : HksCryptoHalAesDecrypt_010
585 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-ECB-NOPADDING key.
586 */
587 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_010, Function | SmallTest | Level0)
588 {
589 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_010_PARAMS);
590 }
591
592 /**
593 * @tc.number : HksCryptoHalAesDecrypt_011
594 * @tc.name : HksCryptoHalAesDecrypt_011
595 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-ECB-PKCS7PADDING key.
596 */
597 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_011, Function | SmallTest | Level0)
598 {
599 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_011_PARAMS);
600 }
601
602 /**
603 * @tc.number : HksCryptoHalAesDecrypt_016
604 * @tc.name : HksCryptoHalAesDecrypt_016
605 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-ECB-NOPADDING key.
606 */
607 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_016, Function | SmallTest | Level0)
608 {
609 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_016_PARAMS);
610 }
611
612 /**
613 * @tc.number : HksCryptoHalAesDecrypt_017
614 * @tc.name : HksCryptoHalAesDecrypt_017
615 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-ECB-PKCS7PADDING key.
616 */
617 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_017, Function | SmallTest | Level0)
618 {
619 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_017_PARAMS);
620 }
621 #endif
622 /**
623 * @tc.number : HksCryptoHalAesDecrypt_006
624 * @tc.name : HksCryptoHalAesDecrypt_006
625 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-GCM-NOPADDING key.
626 */
627 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_006, Function | SmallTest | Level0)
628 {
629 GcmRunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_006_PARAMS);
630 }
631
632 /**
633 * @tc.number : HksCryptoHalAesDecrypt_007
634 * @tc.name : HksCryptoHalAesDecrypt_007
635 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-CBC-NOPADDING key.
636 */
637 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_007, Function | SmallTest | Level0)
638 {
639 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_007_PARAMS);
640 }
641
642 /**
643 * @tc.number : HksCryptoHalAesDecrypt_008
644 * @tc.name : HksCryptoHalAesDecrypt_008
645 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-CBC-PKCS7PADDING key.
646 */
647 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_008, Function | SmallTest | Level0)
648 {
649 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_008_PARAMS);
650 }
651
652 /**
653 * @tc.number : HksCryptoHalAesDecrypt_009
654 * @tc.name : HksCryptoHalAesDecrypt_009
655 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-CTR-NOPADDING key.
656 */
657 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_009, Function | SmallTest | Level0)
658 {
659 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_009_PARAMS);
660 }
661
662
663 /**
664 * @tc.number : HksCryptoHalAesDecrypt_012
665 * @tc.name : HksCryptoHalAesDecrypt_012
666 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-GCM-NOPADDING key.
667 */
668 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_012, Function | SmallTest | Level0)
669 {
670 GcmRunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_012_PARAMS);
671 }
672
673 /**
674 * @tc.number : HksCryptoHalAesDecrypt_013
675 * @tc.name : HksCryptoHalAesDecrypt_013
676 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-CBC-NOPADDING key.
677 */
678 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_013, Function | SmallTest | Level0)
679 {
680 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_013_PARAMS);
681 }
682
683 /**
684 * @tc.number : HksCryptoHalAesDecrypt_014
685 * @tc.name : HksCryptoHalAesDecrypt_014
686 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-CBC-PKCS7PADDING key.
687 */
688 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_014, Function | SmallTest | Level0)
689 {
690 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_014_PARAMS);
691 }
692
693 /**
694 * @tc.number : HksCryptoHalAesDecrypt_015
695 * @tc.name : HksCryptoHalAesDecrypt_015
696 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-CTR-NOPADDING key.
697 */
698 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_015, Function | SmallTest | Level0)
699 {
700 RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_015_PARAMS);
701 }
702
703 /**
704 * @tc.number : HksCryptoHalAesDecrypt_018
705 * @tc.name : HksCryptoHalAesDecrypt_018
706 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-GCM-NOPADDING key.
707 */
708 HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_018, Function | SmallTest | Level0)
709 {
710 GcmRunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_018_PARAMS);
711 }
712 } // namespace UnitTest
713 } // namespace Huks
714 } // namespace Security
715 } // namespace OHOS