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