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 <gtest/gtest.h>
17 #include <fstream>
18 #include <iostream>
19 #include "securec.h"
20 #include "sym_common_defines.h"
21 #include "sym_key_generator.h"
22 #include "cipher.h"
23 #include "blob.h"
24 #include "log.h"
25 #include "memory.h"
26 #include "detailed_iv_params.h"
27 #include "detailed_gcm_params.h"
28 #include "detailed_ccm_params.h"
29 #include "aes_openssl.h"
30
31 using namespace std;
32 using namespace testing::ext;
33
34 namespace {
35 constexpr int32_t KEY_MATERIAL_LEN = 16;
36
37 class CryptoSM4GeneratorTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase()45 void CryptoSM4GeneratorTest::SetUpTestCase() {}
TearDownTestCase()46 void CryptoSM4GeneratorTest::TearDownTestCase() {}
47
SetUp()48 void CryptoSM4GeneratorTest::SetUp() // add init here, this will be called before test.
49 {
50 }
51
TearDown()52 void CryptoSM4GeneratorTest::TearDown() // add destroy here, this will be called when test case done.
53 {
54 }
55
GenerateSymKey(const char * algoName,HcfSymKey ** key)56 static int32_t GenerateSymKey(const char *algoName, HcfSymKey **key)
57 {
58 HcfSymKeyGenerator *generator = nullptr;
59
60 int32_t ret = HcfSymKeyGeneratorCreate(algoName, &generator);
61 if (ret != 0) {
62 LOGE("HcfSymKeyGeneratorCreate failed!");
63 return ret;
64 }
65
66 ret = generator->generateSymKey(generator, key);
67 if (ret != 0) {
68 LOGE("generateSymKey failed!");
69 }
70 HcfObjDestroy((HcfObjectBase *)generator);
71 return ret;
72 }
73
74 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest001, TestSize.Level0)
75 {
76 int ret = 0;
77 HcfSymKeyGenerator *generator = nullptr;
78 HcfSymKey *key = nullptr;
79 const char *inputAlgoName = "SM4_128";
80 const char *generatorAlgoName = nullptr;
81
82 ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
83 ASSERT_EQ(ret, 0);
84 ret = generator->generateSymKey(generator, &key);
85 ASSERT_EQ(ret, 0);
86
87 // generator getAlgoName
88 generatorAlgoName = generator->getAlgoName(generator);
89 ASSERT_NE(generatorAlgoName, nullptr);
90
91 ret = strcmp(generatorAlgoName, inputAlgoName);
92 ASSERT_EQ(ret, 0);
93
94 HcfObjDestroy(key);
95 HcfObjDestroy(generator);
96 }
97
98 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest002, TestSize.Level0)
99 {
100 int ret = 0;
101 HcfSymKeyGenerator *generator = nullptr;
102 const char *generatorAlgoName = nullptr;
103 const char *inputAlgoName = "SM4_128";
104
105 ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
106 ASSERT_EQ(ret, 0);
107
108 // generator getAlgoName
109 generatorAlgoName = generator->getAlgoName(nullptr);
110 ASSERT_EQ(generatorAlgoName, nullptr);
111
112 HcfObjDestroy(generator);
113 }
114
115 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest003, TestSize.Level0)
116 {
117 HcfSymKeyGenerator *generator = nullptr;
118 HcfSymKey *key = nullptr;
119 const char *generatorAlgoName = nullptr;
120 const char *inputAlgoName = "SM4_128";
121
122 int ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
123 ASSERT_EQ(ret, 0);
124 ret = generator->generateSymKey(generator, &key);
125 ASSERT_EQ(ret, 0);
126
127 // generator getAlgoName
128 generatorAlgoName = generator->getAlgoName(reinterpret_cast<HcfSymKeyGenerator *>(key));
129 ASSERT_EQ(generatorAlgoName, nullptr);
130
131 HcfObjDestroy(key);
132 HcfObjDestroy(generator);
133 }
134
135 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest004, TestSize.Level0)
136 {
137 HcfSymKey *key = nullptr;
138 const char *inputAlgoName = "SM4_128";
139 const char *keyAlgoName = nullptr;
140
141 int ret = GenerateSymKey(inputAlgoName, &key);
142 ASSERT_EQ(ret, 0);
143
144 keyAlgoName = key->key.getAlgorithm(nullptr);
145 ASSERT_EQ(keyAlgoName, nullptr);
146
147 HcfObjDestroy(key);
148 }
149
150 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest005, TestSize.Level0)
151 {
152 HcfSymKeyGenerator *generator = nullptr;
153 HcfSymKey *key = nullptr;
154 const char *inputAlgoName = "SM4_128";
155 const char *keyAlgoName = nullptr;
156
157 int ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
158 ASSERT_EQ(ret, 0);
159
160 ret = generator->generateSymKey(generator, &key);
161 ASSERT_EQ(ret, 0);
162
163 keyAlgoName = key->key.getAlgorithm(reinterpret_cast<HcfKey *>(generator));
164 ASSERT_EQ(keyAlgoName, nullptr);
165
166 HcfObjDestroy(key);
167 HcfObjDestroy(generator);
168 }
169
170 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest006, TestSize.Level0)
171 {
172 HcfSymKey *key = nullptr;
173 const char *retFormat = nullptr;
174
175 int ret = GenerateSymKey("SM4_128", &key);
176 ASSERT_EQ(ret, 0);
177
178 retFormat = key->key.getFormat(nullptr);
179 ASSERT_EQ(retFormat, nullptr);
180
181 HcfObjDestroy(key);
182 }
183
184 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest007, TestSize.Level0)
185 {
186 HcfSymKeyGenerator *generator = nullptr;
187 HcfSymKey *key = nullptr;
188 const char *retFormat = nullptr;
189
190 int ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
191 ASSERT_EQ(ret, 0);
192
193 ret = generator->generateSymKey(generator, &key);
194 ASSERT_EQ(ret, 0);
195
196 retFormat = key->key.getFormat(reinterpret_cast<HcfKey *>(generator));
197 ASSERT_EQ(retFormat, nullptr);
198
199 HcfObjDestroy(key);
200 HcfObjDestroy(generator);
201 }
202
203 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest008, TestSize.Level0)
204 {
205 HcfSymKeyGenerator *generator = nullptr;
206 HcfSymKey *key = nullptr;
207 HcfBlob encodedBlob = { 0 };
208 uint8_t keyMaterial[] = {
209 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
210 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
211 };
212 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
213
214 int ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
215 ASSERT_EQ(ret, 0);
216
217 ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
218 ASSERT_EQ(ret, 0);
219
220 ret = key->key.getEncoded(nullptr, &encodedBlob);
221 ASSERT_NE(ret, 0);
222
223 HcfObjDestroy(key);
224 HcfObjDestroy(generator);
225 if (encodedBlob.data != nullptr) {
226 HcfFree(encodedBlob.data);
227 encodedBlob.data = nullptr;
228 }
229 }
230
231 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest009, TestSize.Level0)
232 {
233 HcfSymKeyGenerator *generator = nullptr;
234 HcfSymKey *key = nullptr;
235 HcfBlob encodedBlob = { 0 };
236 uint8_t keyMaterial[] = {
237 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
238 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
239 };
240 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
241
242 int ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
243 ASSERT_EQ(ret, 0);
244
245 ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
246 ASSERT_EQ(ret, 0);
247
248 ret = key->key.getEncoded(reinterpret_cast<HcfKey *>(generator), &encodedBlob);
249 ASSERT_NE(ret, 0);
250
251 HcfObjDestroy(key);
252 HcfObjDestroy(generator);
253 if (encodedBlob.data != nullptr) {
254 HcfFree(encodedBlob.data);
255 encodedBlob.data = nullptr;
256 }
257 }
258
259 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest010, TestSize.Level0)
260 {
261 HcfSymKeyGenerator *generator = nullptr;
262 HcfSymKey *key = nullptr;
263 HcfBlob encodedBlob = { 0 };
264 uint8_t keyMaterial[] = {
265 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
266 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
267 };
268 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
269 SymKeyImpl *impl = nullptr;
270 size_t tmpLen = 0;
271
272 int ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
273 ASSERT_EQ(ret, 0);
274
275 ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
276 ASSERT_EQ(ret, 0);
277
278 impl = reinterpret_cast<SymKeyImpl *>(key);
279 tmpLen = impl->keyMaterial.len;
280 impl->keyMaterial.len = 0;
281
282 ret = key->key.getEncoded(&(key->key), &encodedBlob);
283 impl->keyMaterial.len = tmpLen;
284 ASSERT_NE(ret, 0);
285
286 HcfObjDestroy(key);
287 HcfObjDestroy(generator);
288 if (encodedBlob.data != nullptr) {
289 HcfFree(encodedBlob.data);
290 encodedBlob.data = nullptr;
291 }
292 }
293
294 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest011, TestSize.Level0)
295 {
296 HcfSymKeyGenerator *generator = nullptr;
297 HcfSymKey *key = nullptr;
298 HcfBlob encodedBlob = { 0 };
299 uint8_t keyMaterial[] = {
300 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
301 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
302 };
303 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
304
305 int ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
306 ASSERT_EQ(ret, 0);
307
308 ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
309 ASSERT_EQ(ret, 0);
310
311 key->clearMem(nullptr);
312
313 ret = key->key.getEncoded(&(key->key), &encodedBlob);
314 ASSERT_EQ(ret, 0);
315 ASSERT_FALSE((encodedBlob.data == nullptr) || (encodedBlob.data[0] == '\0'));
316
317 HcfObjDestroy(key);
318 HcfObjDestroy(generator);
319 if (encodedBlob.data != nullptr) {
320 HcfFree(encodedBlob.data);
321 encodedBlob.data = nullptr;
322 }
323 }
324
325 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest012, TestSize.Level0)
326 {
327 int ret = 0;
328 HcfSymKeyGenerator *generator = nullptr;
329
330 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
331 if (ret != 0) {
332 LOGE("HcfSymKeyGeneratorCreate failed! Should not select RSA for symKey generator.");
333 }
334
335 HcfObjDestroy(generator);
336 EXPECT_EQ(ret, 0);
337 }
338
339 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest013, TestSize.Level0)
340 {
341 int ret = 0;
342 HcfSymKeyGenerator *generator = nullptr;
343
344 ret = HcfSymKeyGeneratorCreate("", &generator);
345 if (ret != 0) {
346 LOGE("HcfSymKeyGeneratorCreate failed! Should not select empty string for symKey generator.");
347 }
348
349 HcfObjDestroy(generator);
350 EXPECT_NE(ret, 0);
351 }
352
353 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest014, TestSize.Level0)
354 {
355 int ret = 0;
356 HcfSymKeyGenerator *generator = nullptr;
357
358 ret = HcfSymKeyGeneratorCreate(nullptr, &generator);
359 if (ret != 0) {
360 LOGE("HcfSymKeyGeneratorCreate failed! Should not select nullptr for symKey generator.");
361 }
362
363 HcfObjDestroy(generator);
364 EXPECT_NE(ret, 0);
365 }
366
367 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest015, TestSize.Level0)
368 {
369 int ret = 0;
370 HcfSymKeyGenerator *generator = nullptr;
371
372 ret = HcfSymKeyGeneratorSpiCreate(nullptr, nullptr);
373 if (ret != 0) {
374 LOGE("HcfSymKeyGeneratorSpiCreate failed!");
375 }
376
377 HcfObjDestroy(generator);
378 EXPECT_NE(ret, 0);
379 }
380
381 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest016, TestSize.Level0)
382 {
383 HcfSymKeyGenerator *generator = nullptr;
384 HcfSymKey *key = nullptr;
385
386 int ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
387 ASSERT_EQ(ret, 0);
388
389 ret = generator->generateSymKey(nullptr, &key);
390 ASSERT_NE(ret, 0);
391
392 HcfObjDestroy(key);
393 HcfObjDestroy(generator);
394 }
395
396 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest017, TestSize.Level0)
397 {
398 HcfSymKeyGenerator *generator = nullptr;
399 HcfSymKey *key = nullptr;
400 HcfCipher *cipher = nullptr;
401
402 int ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
403 ASSERT_EQ(ret, 0);
404
405 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
406 ASSERT_EQ(ret, 0);
407
408 ret = generator->generateSymKey(reinterpret_cast<HcfSymKeyGenerator *>(cipher), &key);
409 ASSERT_NE(ret, 0);
410
411 HcfObjDestroy(key);
412 HcfObjDestroy(generator);
413 HcfObjDestroy(cipher);
414 }
415
416 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest018, TestSize.Level0)
417 {
418 HcfSymKeyGenerator *generator = nullptr;
419 HcfSymKey *key = nullptr;
420 uint8_t keyMaterial[] = {
421 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
422 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
423 };
424 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
425
426 int ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
427 ASSERT_EQ(ret, 0);
428
429 ret = generator->convertSymKey(nullptr, &keyTmpBlob, &key);
430 ASSERT_NE(ret, 0);
431
432 HcfObjDestroy(key);
433 HcfObjDestroy(generator);
434 }
435
436 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest019, TestSize.Level0)
437 {
438 HcfSymKeyGenerator *generator = nullptr;
439 HcfSymKey *key = nullptr;
440 uint8_t keyMaterial[] = {
441 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
442 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
443 };
444 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
445 HcfCipher *cipher = nullptr;
446
447 int ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
448 ASSERT_EQ(ret, 0);
449
450 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
451 ASSERT_EQ(ret, 0);
452
453 ret = generator->convertSymKey(reinterpret_cast<HcfSymKeyGenerator *>(cipher), &keyTmpBlob, &key);
454 ASSERT_NE(ret, 0);
455
456 HcfObjDestroy(key);
457 HcfObjDestroy(generator);
458 HcfObjDestroy(cipher);
459 }
460
461 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest020, TestSize.Level0)
462 {
463 HcfSymKeyGenerator *generator = nullptr;
464 HcfSymKey *key = nullptr;
465 uint8_t keyMaterial[] = {
466 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
467 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
468 };
469 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = 0 };
470
471 int ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
472 ASSERT_EQ(ret, 0);
473
474 ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
475 ASSERT_NE(ret, 0);
476
477
478 HcfObjDestroy(key);
479 HcfObjDestroy(generator);
480 }
481 }