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