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 "securec.h"
18 
19 #include "asy_key_generator.h"
20 #include "blob.h"
21 #include "detailed_rsa_key_params.h"
22 #include "detailed_dsa_key_params.h"
23 #include "detailed_ecc_key_params.h"
24 #include "ecc_openssl_common.h"
25 #include "ecc_openssl_common_param_spec.h"
26 #include "ecc_common.h"
27 #include "memory.h"
28 #include "openssl_class.h"
29 #include "openssl_common.h"
30 
31 using namespace std;
32 using namespace testing::ext;
33 
34 namespace {
35 class CryptoAsyKeyGeneratorCovTest : public testing::Test {
36 public:
37     static void SetUpTestCase();
38     static void TearDownTestCase();
39     void SetUp();
40     void TearDown();
41 };
42 
SetUpTestCase()43 void CryptoAsyKeyGeneratorCovTest::SetUpTestCase() {}
44 
TearDownTestCase()45 void CryptoAsyKeyGeneratorCovTest::TearDownTestCase() {}
46 
SetUp()47 void CryptoAsyKeyGeneratorCovTest::SetUp() {}
48 
TearDown()49 void CryptoAsyKeyGeneratorCovTest::TearDown() {}
50 
51 constexpr int32_t INVALID_SPEC_TYPE = 1024;
52 // DSA
53 constexpr uint32_t DSA2048_PRI_SIZE = 20;
54 constexpr uint32_t DSA2048_PUB_SIZE = 256;
55 constexpr uint32_t DSA2048_P_SIZE = 256;
56 constexpr uint32_t DSA2048_Q_SIZE = 20;
57 constexpr uint32_t DSA2048_G_SIZE = 256;
58 
59 static const char *g_algNameDSA = "DSA";
60 static const char *g_invalidAlgName = "null";
61 
62 static const bool IS_BIG_ENDIAN = IsBigEndian();
63 
64 static unsigned char g_dsa2048PrivBigE[] = {
65     0x32, 0x67, 0x92, 0xf6, 0xc4, 0xe2, 0xe2, 0xe8, 0xa0, 0x8b, 0x6b, 0x45,
66     0x0c, 0x8a, 0x76, 0xb0, 0xee, 0xcf, 0x91, 0xa7,
67 };
68 
69 static unsigned char g_dsa2048PrivLittleE[] = {
70     0xa7, 0x91, 0xcf, 0xee, 0xb0, 0x76, 0x8a, 0x0c, 0x45, 0x6b, 0x8b, 0xa0,
71     0xe8, 0xe2, 0xe2, 0xc4, 0xf6, 0x92, 0x67, 0x32,
72 };
73 
74 static unsigned char g_dsa2048PubBigE[] = {
75     0x17, 0x8f, 0xa8, 0x11, 0x84, 0x92, 0xec, 0x83, 0x47, 0xc7, 0x6a, 0xb0,
76     0x92, 0xaf, 0x5a, 0x20, 0x37, 0xa3, 0x64, 0x79, 0xd2, 0xd0, 0x3d, 0xcd,
77     0xe0, 0x61, 0x88, 0x88, 0x21, 0xcc, 0x74, 0x5d, 0xce, 0x4c, 0x51, 0x47,
78     0xf0, 0xc5, 0x5c, 0x4c, 0x82, 0x7a, 0xaf, 0x72, 0xad, 0xb9, 0xe0, 0x53,
79     0xf2, 0x78, 0xb7, 0xf0, 0xb5, 0x48, 0x7f, 0x8a, 0x3a, 0x18, 0xd1, 0x9f,
80     0x8b, 0x7d, 0xa5, 0x47, 0xb7, 0x95, 0xab, 0x98, 0xf8, 0x7b, 0x74, 0x50,
81     0x56, 0x8e, 0x57, 0xf0, 0xee, 0xf5, 0xb7, 0xba, 0xab, 0x85, 0x86, 0xf9,
82     0x2b, 0xef, 0x41, 0x56, 0xa0, 0xa4, 0x9f, 0xb7, 0x38, 0x00, 0x46, 0x0a,
83     0xa6, 0xf1, 0xfc, 0x1f, 0xd8, 0x4e, 0x85, 0x44, 0x92, 0x43, 0x21, 0x5d,
84     0x6e, 0xcc, 0xc2, 0xcb, 0x26, 0x31, 0x0d, 0x21, 0xc4, 0xbd, 0x8d, 0x24,
85     0xbc, 0xd9, 0x18, 0x19, 0xd7, 0xdc, 0xf1, 0xe7, 0x93, 0x50, 0x48, 0x03,
86     0x2c, 0xae, 0x2e, 0xe7, 0x49, 0x88, 0x5f, 0x93, 0x57, 0x27, 0x99, 0x36,
87     0xb4, 0x20, 0xab, 0xfc, 0xa7, 0x2b, 0xf2, 0xd9, 0x98, 0xd7, 0xd4, 0x34,
88     0x9d, 0x96, 0x50, 0x58, 0x9a, 0xea, 0x54, 0xf3, 0xee, 0xf5, 0x63, 0x14,
89     0xee, 0x85, 0x83, 0x74, 0x76, 0xe1, 0x52, 0x95, 0xc3, 0xf7, 0xeb, 0x04,
90     0x04, 0x7b, 0xa7, 0x28, 0x1b, 0xcc, 0xea, 0x4a, 0x4e, 0x84, 0xda, 0xd8,
91     0x9c, 0x79, 0xd8, 0x9b, 0x66, 0x89, 0x2f, 0xcf, 0xac, 0xd7, 0x79, 0xf9,
92     0xa9, 0xd8, 0x45, 0x13, 0x78, 0xb9, 0x00, 0x14, 0xc9, 0x7e, 0x22, 0x51,
93     0x86, 0x67, 0xb0, 0x9f, 0x26, 0x11, 0x23, 0xc8, 0x38, 0xd7, 0x70, 0x1d,
94     0x15, 0x8e, 0x4d, 0x4f, 0x95, 0x97, 0x40, 0xa1, 0xc2, 0x7e, 0x01, 0x18,
95     0x72, 0xf4, 0x10, 0xe6, 0x8d, 0x52, 0x16, 0x7f, 0xf2, 0xc9, 0xf8, 0x33,
96     0x8b, 0x33, 0xb7, 0xce,
97 };
98 
99 static unsigned char g_dsa2048PubLittleE[] = {
100     0xce, 0xb7, 0x33, 0x8b, 0x33, 0xf8, 0xc9, 0xf2, 0x7f, 0x16, 0x52, 0x8d,
101     0xe6, 0x10, 0xf4, 0x72, 0x18, 0x01, 0x7e, 0xc2, 0xa1, 0x40, 0x97, 0x95,
102     0x4f, 0x4d, 0x8e, 0x15, 0x1d, 0x70, 0xd7, 0x38, 0xc8, 0x23, 0x11, 0x26,
103     0x9f, 0xb0, 0x67, 0x86, 0x51, 0x22, 0x7e, 0xc9, 0x14, 0x00, 0xb9, 0x78,
104     0x13, 0x45, 0xd8, 0xa9, 0xf9, 0x79, 0xd7, 0xac, 0xcf, 0x2f, 0x89, 0x66,
105     0x9b, 0xd8, 0x79, 0x9c, 0xd8, 0xda, 0x84, 0x4e, 0x4a, 0xea, 0xcc, 0x1b,
106     0x28, 0xa7, 0x7b, 0x04, 0x04, 0xeb, 0xf7, 0xc3, 0x95, 0x52, 0xe1, 0x76,
107     0x74, 0x83, 0x85, 0xee, 0x14, 0x63, 0xf5, 0xee, 0xf3, 0x54, 0xea, 0x9a,
108     0x58, 0x50, 0x96, 0x9d, 0x34, 0xd4, 0xd7, 0x98, 0xd9, 0xf2, 0x2b, 0xa7,
109     0xfc, 0xab, 0x20, 0xb4, 0x36, 0x99, 0x27, 0x57, 0x93, 0x5f, 0x88, 0x49,
110     0xe7, 0x2e, 0xae, 0x2c, 0x03, 0x48, 0x50, 0x93, 0xe7, 0xf1, 0xdc, 0xd7,
111     0x19, 0x18, 0xd9, 0xbc, 0x24, 0x8d, 0xbd, 0xc4, 0x21, 0x0d, 0x31, 0x26,
112     0xcb, 0xc2, 0xcc, 0x6e, 0x5d, 0x21, 0x43, 0x92, 0x44, 0x85, 0x4e, 0xd8,
113     0x1f, 0xfc, 0xf1, 0xa6, 0x0a, 0x46, 0x00, 0x38, 0xb7, 0x9f, 0xa4, 0xa0,
114     0x56, 0x41, 0xef, 0x2b, 0xf9, 0x86, 0x85, 0xab, 0xba, 0xb7, 0xf5, 0xee,
115     0xf0, 0x57, 0x8e, 0x56, 0x50, 0x74, 0x7b, 0xf8, 0x98, 0xab, 0x95, 0xb7,
116     0x47, 0xa5, 0x7d, 0x8b, 0x9f, 0xd1, 0x18, 0x3a, 0x8a, 0x7f, 0x48, 0xb5,
117     0xf0, 0xb7, 0x78, 0xf2, 0x53, 0xe0, 0xb9, 0xad, 0x72, 0xaf, 0x7a, 0x82,
118     0x4c, 0x5c, 0xc5, 0xf0, 0x47, 0x51, 0x4c, 0xce, 0x5d, 0x74, 0xcc, 0x21,
119     0x88, 0x88, 0x61, 0xe0, 0xcd, 0x3d, 0xd0, 0xd2, 0x79, 0x64, 0xa3, 0x37,
120     0x20, 0x5a, 0xaf, 0x92, 0xb0, 0x6a, 0xc7, 0x47, 0x83, 0xec, 0x92, 0x84,
121     0x11, 0xa8, 0x8f, 0x17,
122 };
123 
124 static unsigned char g_dsa2048PBigE[] = {
125     0xA0, 0x25, 0xFA, 0xAD, 0xF4, 0x8E, 0xB9, 0xE5, 0x99, 0xF3, 0x5D, 0x6F,
126     0x4F, 0x83, 0x34, 0xE2, 0x7E, 0xCF, 0x6F, 0xBF, 0x30, 0xAF, 0x6F, 0x81,
127     0xEB, 0xF8, 0xC4, 0x13, 0xD9, 0xA0, 0x5D, 0x8B, 0x5C, 0x8E, 0xDC, 0xC2,
128     0x1D, 0x0B, 0x41, 0x32, 0xB0, 0x1F, 0xFE, 0xEF, 0x0C, 0xC2, 0xA2, 0x7E,
129     0x68, 0x5C, 0x28, 0x21, 0xE9, 0xF5, 0xB1, 0x58, 0x12, 0x63, 0x4C, 0x19,
130     0x4E, 0xFF, 0x02, 0x4B, 0x92, 0xED, 0xD2, 0x07, 0x11, 0x4D, 0x8C, 0x58,
131     0x16, 0x5C, 0x55, 0x8E, 0xAD, 0xA3, 0x67, 0x7D, 0xB9, 0x86, 0x6E, 0x0B,
132     0xE6, 0x54, 0x6F, 0x40, 0xAE, 0x0E, 0x67, 0x4C, 0xF9, 0x12, 0x5B, 0x3C,
133     0x08, 0x7A, 0xF7, 0xFC, 0x67, 0x86, 0x69, 0xE7, 0x0A, 0x94, 0x40, 0xBF,
134     0x8B, 0x76, 0xFE, 0x26, 0xD1, 0xF2, 0xA1, 0x1A, 0x84, 0xA1, 0x43, 0x56,
135     0x28, 0xBC, 0x9A, 0x5F, 0xD7, 0x3B, 0x69, 0x89, 0x8A, 0x36, 0x2C, 0x51,
136     0xDF, 0x12, 0x77, 0x2F, 0x57, 0x7B, 0xA0, 0xAA, 0xDD, 0x7F, 0xA1, 0x62,
137     0x3B, 0x40, 0x7B, 0x68, 0x1A, 0x8F, 0x0D, 0x38, 0xBB, 0x21, 0x5D, 0x18,
138     0xFC, 0x0F, 0x46, 0xF7, 0xA3, 0xB0, 0x1D, 0x23, 0xC3, 0xD2, 0xC7, 0x72,
139     0x51, 0x18, 0xDF, 0x46, 0x95, 0x79, 0xD9, 0xBD, 0xB5, 0x19, 0x02, 0x2C,
140     0x87, 0xDC, 0xE7, 0x57, 0x82, 0x7E, 0xF1, 0x8B, 0x06, 0x3D, 0x00, 0xA5,
141     0x7B, 0x6B, 0x26, 0x27, 0x91, 0x0F, 0x6A, 0x77, 0xE4, 0xD5, 0x04, 0xE4,
142     0x12, 0x2C, 0x42, 0xFF, 0xD2, 0x88, 0xBB, 0xD3, 0x92, 0xA0, 0xF9, 0xC8,
143     0x51, 0x64, 0x14, 0x5C, 0xD8, 0xF9, 0x6C, 0x47, 0x82, 0xB4, 0x1C, 0x7F,
144     0x09, 0xB8, 0xF0, 0x25, 0x83, 0x1D, 0x3F, 0x3F, 0x05, 0xB3, 0x21, 0x0A,
145     0x5D, 0xA7, 0xD8, 0x54, 0xC3, 0x65, 0x7D, 0xC3, 0xB0, 0x1D, 0xBF, 0xAE,
146     0xF8, 0x68, 0xCF, 0x9B,
147 };
148 
149 static unsigned char g_dsa2048PLittleE[] = {
150     0x9b, 0xcf, 0x68, 0xf8, 0xae, 0xbf, 0x1d, 0xb0, 0xc3, 0x7d, 0x65, 0xc3,
151     0x54, 0xd8, 0xa7, 0x5d, 0x0a, 0x21, 0xb3, 0x05, 0x3f, 0x3f, 0x1d, 0x83,
152     0x25, 0xf0, 0xb8, 0x09, 0x7f, 0x1c, 0xb4, 0x82, 0x47, 0x6c, 0xf9, 0xd8,
153     0x5c, 0x14, 0x64, 0x51, 0xc8, 0xf9, 0xa0, 0x92, 0xd3, 0xbb, 0x88, 0xd2,
154     0xff, 0x42, 0x2c, 0x12, 0xe4, 0x04, 0xd5, 0xe4, 0x77, 0x6a, 0x0f, 0x91,
155     0x27, 0x26, 0x6b, 0x7b, 0xa5, 0x00, 0x3d, 0x06, 0x8b, 0xf1, 0x7e, 0x82,
156     0x57, 0xe7, 0xdc, 0x87, 0x2c, 0x02, 0x19, 0xb5, 0xbd, 0xd9, 0x79, 0x95,
157     0x46, 0xdf, 0x18, 0x51, 0x72, 0xc7, 0xd2, 0xc3, 0x23, 0x1d, 0xb0, 0xa3,
158     0xf7, 0x46, 0x0f, 0xfc, 0x18, 0x5d, 0x21, 0xbb, 0x38, 0x0d, 0x8f, 0x1a,
159     0x68, 0x7b, 0x40, 0x3b, 0x62, 0xa1, 0x7f, 0xdd, 0xaa, 0xa0, 0x7b, 0x57,
160     0x2f, 0x77, 0x12, 0xdf, 0x51, 0x2c, 0x36, 0x8a, 0x89, 0x69, 0x3b, 0xd7,
161     0x5f, 0x9a, 0xbc, 0x28, 0x56, 0x43, 0xa1, 0x84, 0x1a, 0xa1, 0xf2, 0xd1,
162     0x26, 0xfe, 0x76, 0x8b, 0xbf, 0x40, 0x94, 0x0a, 0xe7, 0x69, 0x86, 0x67,
163     0xfc, 0xf7, 0x7a, 0x08, 0x3c, 0x5b, 0x12, 0xf9, 0x4c, 0x67, 0x0e, 0xae,
164     0x40, 0x6f, 0x54, 0xe6, 0x0b, 0x6e, 0x86, 0xb9, 0x7d, 0x67, 0xa3, 0xad,
165     0x8e, 0x55, 0x5c, 0x16, 0x58, 0x8c, 0x4d, 0x11, 0x07, 0xd2, 0xed, 0x92,
166     0x4b, 0x02, 0xff, 0x4e, 0x19, 0x4c, 0x63, 0x12, 0x58, 0xb1, 0xf5, 0xe9,
167     0x21, 0x28, 0x5c, 0x68, 0x7e, 0xa2, 0xc2, 0x0c, 0xef, 0xfe, 0x1f, 0xb0,
168     0x32, 0x41, 0x0b, 0x1d, 0xc2, 0xdc, 0x8e, 0x5c, 0x8b, 0x5d, 0xa0, 0xd9,
169     0x13, 0xc4, 0xf8, 0xeb, 0x81, 0x6f, 0xaf, 0x30, 0xbf, 0x6f, 0xcf, 0x7e,
170     0xe2, 0x34, 0x83, 0x4f, 0x6f, 0x5d, 0xf3, 0x99, 0xe5, 0xb9, 0x8e, 0xf4,
171     0xad, 0xfa, 0x25, 0xa0,
172 };
173 
174 static unsigned char g_dsa2048QBigE[] = {
175     0x97, 0xE7, 0x33, 0x4D, 0xD3, 0x94, 0x3E, 0x0B, 0xDB, 0x62, 0x74, 0xC6,
176     0xA1, 0x08, 0xDD, 0x19, 0xA3, 0x75, 0x17, 0x1B,
177 };
178 
179 static unsigned char g_dsa2048QLittleE[] = {
180     0x1b, 0x17, 0x75, 0xa3, 0x19, 0xdd, 0x08, 0xa1, 0xc6, 0x74, 0x62, 0xdb,
181     0x0b, 0x3e, 0x94, 0xd3, 0x4d, 0x33, 0xe7, 0x97,
182 };
183 
184 static unsigned char g_dsa2048GBigE[] = {
185     0x2C, 0x78, 0x16, 0x59, 0x34, 0x63, 0xF4, 0xF3, 0x92, 0xFC, 0xB5, 0xA5,
186     0x4F, 0x13, 0xDE, 0x2F, 0x1C, 0xA4, 0x3C, 0xAE, 0xAD, 0x38, 0x3F, 0x7E,
187     0x90, 0xBF, 0x96, 0xA6, 0xAE, 0x25, 0x90, 0x72, 0xF5, 0x8E, 0x80, 0x0C,
188     0x39, 0x1C, 0xD9, 0xEC, 0xBA, 0x90, 0x5B, 0x3A, 0xE8, 0x58, 0x6C, 0x9E,
189     0x30, 0x42, 0x37, 0x02, 0x31, 0x82, 0xBC, 0x6A, 0xDF, 0x6A, 0x09, 0x29,
190     0xE3, 0xC0, 0x46, 0xD1, 0xCB, 0x85, 0xEC, 0x0C, 0x30, 0x5E, 0xEA, 0xC8,
191     0x39, 0x8E, 0x22, 0x9F, 0x22, 0x10, 0xD2, 0x34, 0x61, 0x68, 0x37, 0x3D,
192     0x2E, 0x4A, 0x5B, 0x9A, 0xF5, 0xC1, 0x48, 0xC6, 0xF6, 0xDC, 0x63, 0x1A,
193     0xD3, 0x96, 0x64, 0xBA, 0x34, 0xC9, 0xD1, 0xA0, 0xD1, 0xAE, 0x6C, 0x2F,
194     0x48, 0x17, 0x93, 0x14, 0x43, 0xED, 0xF0, 0x21, 0x30, 0x19, 0xC3, 0x1B,
195     0x5F, 0xDE, 0xA3, 0xF0, 0x70, 0x78, 0x18, 0xE1, 0xA8, 0xE4, 0xEE, 0x2E,
196     0x00, 0xA5, 0xE4, 0xB3, 0x17, 0xC8, 0x0C, 0x7D, 0x6E, 0x42, 0xDC, 0xB7,
197     0x46, 0x00, 0x36, 0x4D, 0xD4, 0x46, 0xAA, 0x3D, 0x3C, 0x46, 0x89, 0x40,
198     0xBF, 0x1D, 0x84, 0x77, 0x0A, 0x75, 0xF3, 0x87, 0x1D, 0x08, 0x4C, 0xA6,
199     0xD1, 0xA9, 0x1C, 0x1E, 0x12, 0x1E, 0xE1, 0xC7, 0x30, 0x28, 0x76, 0xA5,
200     0x7F, 0x6C, 0x85, 0x96, 0x2B, 0x6F, 0xDB, 0x80, 0x66, 0x26, 0xAE, 0xF5,
201     0x93, 0xC7, 0x8E, 0xAE, 0x9A, 0xED, 0xE4, 0xCA, 0x04, 0xEA, 0x3B, 0x72,
202     0xEF, 0xDC, 0x87, 0xED, 0x0D, 0xA5, 0x4C, 0x4A, 0xDD, 0x71, 0x22, 0x64,
203     0x59, 0x69, 0x4E, 0x8E, 0xBF, 0x43, 0xDC, 0xAB, 0x8E, 0x66, 0xBB, 0x01,
204     0xB6, 0xF4, 0xE7, 0xFD, 0xD2, 0xAD, 0x9F, 0x36, 0xC1, 0xA0, 0x29, 0x99,
205     0xD1, 0x96, 0x70, 0x59, 0x06, 0x78, 0x35, 0xBD, 0x65, 0x55, 0x52, 0x9E,
206     0xF8, 0xB2, 0xE5, 0x38,
207 };
208 
209 static unsigned char g_dsa2048GLittleE[] = {
210     0x38, 0xe5, 0xb2, 0xf8, 0x9e, 0x52, 0x55, 0x65, 0xbd, 0x35, 0x78, 0x06,
211     0x59, 0x70, 0x96, 0xd1, 0x99, 0x29, 0xa0, 0xc1, 0x36, 0x9f, 0xad, 0xd2,
212     0xfd, 0xe7, 0xf4, 0xb6, 0x01, 0xbb, 0x66, 0x8e, 0xab, 0xdc, 0x43, 0xbf,
213     0x8e, 0x4e, 0x69, 0x59, 0x64, 0x22, 0x71, 0xdd, 0x4a, 0x4c, 0xa5, 0x0d,
214     0xed, 0x87, 0xdc, 0xef, 0x72, 0x3b, 0xea, 0x04, 0xca, 0xe4, 0xed, 0x9a,
215     0xae, 0x8e, 0xc7, 0x93, 0xf5, 0xae, 0x26, 0x66, 0x80, 0xdb, 0x6f, 0x2b,
216     0x96, 0x85, 0x6c, 0x7f, 0xa5, 0x76, 0x28, 0x30, 0xc7, 0xe1, 0x1e, 0x12,
217     0x1e, 0x1c, 0xa9, 0xd1, 0xa6, 0x4c, 0x08, 0x1d, 0x87, 0xf3, 0x75, 0x0a,
218     0x77, 0x84, 0x1d, 0xbf, 0x40, 0x89, 0x46, 0x3c, 0x3d, 0xaa, 0x46, 0xd4,
219     0x4d, 0x36, 0x00, 0x46, 0xb7, 0xdc, 0x42, 0x6e, 0x7d, 0x0c, 0xc8, 0x17,
220     0xb3, 0xe4, 0xa5, 0x00, 0x2e, 0xee, 0xe4, 0xa8, 0xe1, 0x18, 0x78, 0x70,
221     0xf0, 0xa3, 0xde, 0x5f, 0x1b, 0xc3, 0x19, 0x30, 0x21, 0xf0, 0xed, 0x43,
222     0x14, 0x93, 0x17, 0x48, 0x2f, 0x6c, 0xae, 0xd1, 0xa0, 0xd1, 0xc9, 0x34,
223     0xba, 0x64, 0x96, 0xd3, 0x1a, 0x63, 0xdc, 0xf6, 0xc6, 0x48, 0xc1, 0xf5,
224     0x9a, 0x5b, 0x4a, 0x2e, 0x3d, 0x37, 0x68, 0x61, 0x34, 0xd2, 0x10, 0x22,
225     0x9f, 0x22, 0x8e, 0x39, 0xc8, 0xea, 0x5e, 0x30, 0x0c, 0xec, 0x85, 0xcb,
226     0xd1, 0x46, 0xc0, 0xe3, 0x29, 0x09, 0x6a, 0xdf, 0x6a, 0xbc, 0x82, 0x31,
227     0x02, 0x37, 0x42, 0x30, 0x9e, 0x6c, 0x58, 0xe8, 0x3a, 0x5b, 0x90, 0xba,
228     0xec, 0xd9, 0x1c, 0x39, 0x0c, 0x80, 0x8e, 0xf5, 0x72, 0x90, 0x25, 0xae,
229     0xa6, 0x96, 0xbf, 0x90, 0x7e, 0x3f, 0x38, 0xad, 0xae, 0x3c, 0xa4, 0x1c,
230     0x2f, 0xde, 0x13, 0x4f, 0xa5, 0xb5, 0xfc, 0x92, 0xf3, 0xf4, 0x63, 0x34,
231     0x59, 0x16, 0x78, 0x2c,
232 };
233 
234 static HcfBigInteger g_dsaCorrectSkBn = {
235     .data = IS_BIG_ENDIAN ? g_dsa2048PrivBigE : g_dsa2048PrivLittleE, .len = DSA2048_PRI_SIZE };
236 static HcfBigInteger g_dsaCorrectPkBn = {
237     .data = IS_BIG_ENDIAN ? g_dsa2048PubBigE : g_dsa2048PubLittleE, .len = DSA2048_PUB_SIZE };
238 static HcfBigInteger g_dsaCorrectPBn = {
239     .data = IS_BIG_ENDIAN ? g_dsa2048PBigE : g_dsa2048PLittleE, .len = DSA2048_P_SIZE };
240 static HcfBigInteger g_dsaCorrectQBn = {
241     .data = IS_BIG_ENDIAN ? g_dsa2048QBigE : g_dsa2048QLittleE, .len = DSA2048_Q_SIZE };
242 static HcfBigInteger g_dsaCorrectGBn = {
243     .data = IS_BIG_ENDIAN ? g_dsa2048GBigE : g_dsa2048GLittleE, .len = DSA2048_G_SIZE };
244 static HcfBigInteger g_dsaNullSkBn = {
245     .data = nullptr, .len = DSA2048_PRI_SIZE };
246 static HcfBigInteger g_dsaNullPkBn = {
247     .data = nullptr, .len = DSA2048_PUB_SIZE };
248 static HcfBigInteger g_dsaNullPBn = { .data = nullptr, .len = DSA2048_P_SIZE };
249 static HcfBigInteger g_dsaNullQBn = { .data = nullptr, .len = DSA2048_Q_SIZE };
250 static HcfBigInteger g_dsaNullGBn = { .data = nullptr, .len = DSA2048_G_SIZE };
251 static HcfBigInteger g_dsaNoLenSkBn = {
252     .data = IS_BIG_ENDIAN ? g_dsa2048PrivBigE : g_dsa2048PrivLittleE, .len = 0 };
253 static HcfBigInteger g_dsaNoLenPkBn = {
254     .data = IS_BIG_ENDIAN ? g_dsa2048PubBigE : g_dsa2048PubLittleE, .len = 0 };
255 static HcfBigInteger g_dsaNoLenPBn = { .data = IS_BIG_ENDIAN ? g_dsa2048PBigE : g_dsa2048PLittleE, .len = 0 };
256 static HcfBigInteger g_dsaNoLenQBn = { .data = IS_BIG_ENDIAN ? g_dsa2048QBigE : g_dsa2048QLittleE, .len = 0 };
257 static HcfBigInteger g_dsaNoLenGBn = { .data = IS_BIG_ENDIAN ? g_dsa2048GBigE : g_dsa2048GLittleE, .len = 0 };
258 
259 static HcfAsyKeyParamsSpec dsaAsySpecCommCorrect = {
260     .algName = const_cast<char *>(g_algNameDSA),
261     .specType = HCF_COMMON_PARAMS_SPEC
262 };
263 static HcfAsyKeyParamsSpec dsaAsySpecPkCorrect = {
264     .algName = const_cast<char *>(g_algNameDSA),
265     .specType = HCF_PUBLIC_KEY_SPEC
266 };
267 static HcfAsyKeyParamsSpec dsaAsySpecKeyPairCorrect = {
268     .algName = const_cast<char *>(g_algNameDSA),
269     .specType = HCF_KEY_PAIR_SPEC
270 };
271 static HcfAsyKeyParamsSpec dsaAsySpecNoAlg = {
272     .algName = nullptr,
273     .specType = HCF_KEY_PAIR_SPEC
274 };
275 static HcfAsyKeyParamsSpec dsaAsySpecErrorAlg = {
276     .algName = const_cast<char *>(g_invalidAlgName),
277     .specType = HCF_KEY_PAIR_SPEC
278 };
279 static HcfAsyKeyParamsSpec dsaAsySpecKeyPairErrorSpecType = {
280     .algName = const_cast<char *>(g_algNameDSA),
281     .specType = HCF_PRIVATE_KEY_SPEC
282 };
283 
284 static HcfDsaCommParamsSpec dsaCommonSpecNoAlg = {
285     .base = dsaAsySpecNoAlg, .p = g_dsaCorrectPBn, .q = g_dsaCorrectQBn, .g = g_dsaCorrectGBn
286 };
287 static HcfDsaCommParamsSpec dsaCommonSpecErrorAlg = {
288     .base = dsaAsySpecErrorAlg, .p = g_dsaCorrectPBn, .q = g_dsaCorrectQBn, .g = g_dsaCorrectGBn
289 };
290 static HcfDsaCommParamsSpec dsaCommonSpecNullP = {
291     .base = dsaAsySpecCommCorrect, .p = g_dsaNullPBn, .q = g_dsaCorrectQBn, .g = g_dsaCorrectGBn
292 };
293 static HcfDsaCommParamsSpec dsaCommonSpecNoLenP = {
294     .base = dsaAsySpecCommCorrect, .p = g_dsaNoLenPBn, .q = g_dsaCorrectQBn, .g = g_dsaCorrectGBn
295 };
296 static HcfDsaCommParamsSpec dsaCommonSpecNullQ = {
297     .base = dsaAsySpecCommCorrect, .p = g_dsaCorrectPBn, .q = g_dsaNullQBn, .g = g_dsaCorrectGBn
298 };
299 static HcfDsaCommParamsSpec dsaCommonSpecNoLenQ = {
300     .base = dsaAsySpecCommCorrect, .p = g_dsaCorrectPBn, .q = g_dsaNoLenQBn, .g = g_dsaCorrectGBn
301 };
302 static HcfDsaCommParamsSpec dsaCommonSpecNullG = {
303     .base = dsaAsySpecCommCorrect, .p = g_dsaCorrectPBn, .q = g_dsaCorrectQBn, .g = g_dsaNullGBn
304 };
305 static HcfDsaCommParamsSpec dsaCommonSpecNoLenG = {
306     .base = dsaAsySpecCommCorrect, .p = g_dsaCorrectPBn, .q = g_dsaCorrectQBn, .g = g_dsaNoLenGBn
307 };
308 
309 static HcfDsaPubKeyParamsSpec dsaPkSpecErrorComm = {
310     .base = {
311         .base = dsaAsySpecPkCorrect,
312         .p = g_dsaNullPBn,
313         .q = g_dsaCorrectQBn,
314         .g = g_dsaCorrectGBn
315     },
316     .pk = g_dsaCorrectPkBn
317 };
318 static HcfDsaPubKeyParamsSpec dsaPkSpecNullPk = {
319     .base = {
320         .base = dsaAsySpecPkCorrect,
321         .p = g_dsaCorrectPBn,
322         .q = g_dsaCorrectQBn,
323         .g = g_dsaCorrectGBn
324     },
325     .pk = g_dsaNullPkBn
326 };
327 static HcfDsaPubKeyParamsSpec dsaPkSpecNoLenPk = {
328     .base = {
329         .base = dsaAsySpecPkCorrect,
330         .p = g_dsaCorrectPBn,
331         .q = g_dsaCorrectQBn,
332         .g = g_dsaCorrectGBn
333     },
334     .pk = g_dsaNoLenPkBn
335 };
336 
337 static HcfDsaKeyPairParamsSpec dsaKeyPairSpecErrorSpecType = {
338     .base = {
339         .base = dsaAsySpecKeyPairErrorSpecType,
340         .p = g_dsaCorrectPBn,
341         .q = g_dsaCorrectQBn,
342         .g = g_dsaCorrectGBn
343     },
344     .pk = g_dsaCorrectPkBn,
345     .sk = g_dsaCorrectSkBn
346 };
347 static HcfDsaKeyPairParamsSpec dsaKeyPairSpecErrorComm = {
348     .base = {
349         .base = dsaAsySpecKeyPairCorrect,
350         .p = g_dsaNullPBn,
351         .q = g_dsaCorrectQBn,
352         .g = g_dsaCorrectGBn
353     },
354     .pk = g_dsaCorrectPkBn,
355     .sk = g_dsaCorrectSkBn
356 };
357 static HcfDsaKeyPairParamsSpec dsaKeyPairSpecNullPk = {
358     .base = {
359         .base = dsaAsySpecKeyPairCorrect,
360         .p = g_dsaCorrectPBn,
361         .q = g_dsaCorrectQBn,
362         .g = g_dsaCorrectGBn
363     },
364     .pk = g_dsaNullPkBn,
365     .sk = g_dsaCorrectSkBn
366 };
367 static HcfDsaKeyPairParamsSpec dsaKeyPairSpecNoLenPk = {
368     .base = {
369         .base = dsaAsySpecKeyPairCorrect,
370         .p = g_dsaCorrectPBn,
371         .q = g_dsaCorrectQBn,
372         .g = g_dsaCorrectGBn
373     },
374     .pk = g_dsaNoLenPkBn,
375     .sk = g_dsaCorrectSkBn
376 };
377 static HcfDsaKeyPairParamsSpec dsaKeyPairSpecNullSk = {
378     .base = {
379         .base = dsaAsySpecKeyPairCorrect,
380         .p = g_dsaCorrectPBn,
381         .q = g_dsaCorrectQBn,
382         .g = g_dsaCorrectGBn
383     },
384     .pk = g_dsaCorrectPkBn,
385     .sk = g_dsaNullSkBn
386 };
387 static HcfDsaKeyPairParamsSpec dsaKeyPairSpecNoLenSk = {
388     .base = {
389         .base = dsaAsySpecKeyPairCorrect,
390         .p = g_dsaCorrectPBn,
391         .q = g_dsaCorrectQBn,
392         .g = g_dsaCorrectGBn
393     },
394     .pk = g_dsaCorrectPkBn,
395     .sk = g_dsaNoLenSkBn
396 };
397 
398 // RSA SPEC
399 constexpr uint32_t RSA_2048_N_BYTE_SIZE = 256;
400 constexpr uint32_t RSA_2048_D_BYTE_SIZE = 256;
401 constexpr uint32_t RSA_2048_E_BYTE_SIZE = 3;
402 
403 constexpr unsigned char RSA_2048_CORRECT_N[] =
404     "\x92\x60\xd0\x75\x0a\xe1\x17\xee\xe5\x5c\x3f\x3d\xea\xba\x74\x91"
405     "\x75\x21\xa2\x62\xee\x76\x00\x7c\xdf\x8a\x56\x75\x5a\xd7\x3a\x15"
406     "\x98\xa1\x40\x84\x10\xa0\x14\x34\xc3\xf5\xbc\x54\xa8\x8b\x57\xfa"
407     "\x19\xfc\x43\x28\xda\xea\x07\x50\xa4\xc4\x4e\x88\xcf\xf3\xb2\x38"
408     "\x26\x21\xb8\x0f\x67\x04\x64\x43\x3e\x43\x36\xe6\xd0\x03\xe8\xcd"
409     "\x65\xbf\xf2\x11\xda\x14\x4b\x88\x29\x1c\x22\x59\xa0\x0a\x72\xb7"
410     "\x11\xc1\x16\xef\x76\x86\xe8\xfe\xe3\x4e\x4d\x93\x3c\x86\x81\x87"
411     "\xbd\xc2\x6f\x7b\xe0\x71\x49\x3c\x86\xf7\xa5\x94\x1c\x35\x10\x80"
412     "\x6a\xd6\x7b\x0f\x94\xd8\x8f\x5c\xf5\xc0\x2a\x09\x28\x21\xd8\x62"
413     "\x6e\x89\x32\xb6\x5c\x5b\xd8\xc9\x20\x49\xc2\x10\x93\x2b\x7a\xfa"
414     "\x7a\xc5\x9c\x0e\x88\x6a\xe5\xc1\xed\xb0\x0d\x8c\xe2\xc5\x76\x33"
415     "\xdb\x26\xbd\x66\x39\xbf\xf7\x3c\xee\x82\xbe\x92\x75\xc4\x02\xb4"
416     "\xcf\x2a\x43\x88\xda\x8c\xf8\xc6\x4e\xef\xe1\xc5\xa0\xf5\xab\x80"
417     "\x57\xc3\x9f\xa5\xc0\x58\x9c\x3e\x25\x3f\x09\x60\x33\x23\x00\xf9"
418     "\x4b\xea\x44\x87\x7b\x58\x8e\x1e\xdb\xde\x97\xcf\x23\x60\x72\x7a"
419     "\x09\xb7\x75\x26\x2d\x7e\xe5\x52\xb3\x31\x9b\x92\x66\xf0\x5a\x25";
420 
421 constexpr unsigned char RSA_2048_CORRECT_E[] = "\x01\x00\x01";
422 
423 constexpr unsigned char RSA_2048_CORRECT_D[] =
424     "\x6a\x7d\xf2\xca\x63\xea\xd4\xdd\xa1\x91\xd6\x14\xb6\xb3\x85\xe0"
425     "\xd9\x05\x6a\x3d\x6d\x5c\xfe\x07\xdb\x1d\xaa\xbe\xe0\x22\xdb\x08"
426     "\x21\x2d\x97\x61\x3d\x33\x28\xe0\x26\x7c\x9d\xd2\x3d\x78\x7a\xbd"
427     "\xe2\xaf\xcb\x30\x6a\xeb\x7d\xfc\xe6\x92\x46\xcc\x73\xf5\xc8\x7f"
428     "\xdf\x06\x03\x01\x79\xa2\x11\x4b\x76\x7d\xb1\xf0\x83\xff\x84\x1c"
429     "\x02\x5d\x7d\xc0\x0c\xd8\x24\x35\xb9\xa9\x0f\x69\x53\x69\xe9\x4d"
430     "\xf2\x3d\x2c\xe4\x58\xbc\x3b\x32\x83\xad\x8b\xba\x2b\x8f\xa1\xba"
431     "\x62\xe2\xdc\xe9\xac\xcf\xf3\x79\x9a\xae\x7c\x84\x00\x16\xf3\xba"
432     "\x8e\x00\x48\xc0\xb6\xcc\x43\x39\xaf\x71\x61\x00\x3a\x5b\xeb\x86"
433     "\x4a\x01\x64\xb2\xc1\xc9\x23\x7b\x64\xbc\x87\x55\x69\x94\x35\x1b"
434     "\x27\x50\x6c\x33\xd4\xbc\xdf\xce\x0f\x9c\x49\x1a\x7d\x6b\x06\x28"
435     "\xc7\xc8\x52\xbe\x4f\x0a\x9c\x31\x32\xb2\xed\x3a\x2c\x88\x81\xe9"
436     "\xaa\xb0\x7e\x20\xe1\x7d\xeb\x07\x46\x91\xbe\x67\x77\x76\xa7\x8b"
437     "\x5c\x50\x2e\x05\xd9\xbd\xde\x72\x12\x6b\x37\x38\x69\x5e\x2d\xd1"
438     "\xa0\xa9\x8a\x14\x24\x7c\x65\xd8\xa7\xee\x79\x43\x2a\x09\x2c\xb0"
439     "\x72\x1a\x12\xdf\x79\x8e\x44\xf7\xcf\xce\x0c\x49\x81\x47\xa9\xb1";
440 
441 const char *g_rsaAlgName = "RSA";
442 
RemoveLastChar(const unsigned char * str,unsigned char * dest,uint32_t destLen)443 static void RemoveLastChar(const unsigned char *str, unsigned char *dest, uint32_t destLen)
444 {
445     for (size_t i = 0; i < destLen; i++) {
446         dest[i] = str[i];
447     }
448     return;
449 }
450 
EndianSwap(unsigned char * pData,int startIndex,int length)451 static void EndianSwap(unsigned char *pData, int startIndex, int length)
452 {
453     int cnt = length / 2;
454     int start = startIndex;
455     int end  = startIndex + length - 1;
456     unsigned char tmp;
457     for (int i = 0; i < cnt; i++) {
458         tmp = pData[start + i];
459         pData[start + i] = pData[end - i];
460         pData[end - i] = tmp;
461     }
462 }
463 
464 // 2048 defined the length of byte array
GenerateRsa2048CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)465 static void GenerateRsa2048CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
466 {
467     RemoveLastChar(RSA_2048_CORRECT_N, dataN, RSA_2048_N_BYTE_SIZE);
468     if (!IsBigEndian()) {
469         // the device is not big endian
470         EndianSwap(dataN, 0, RSA_2048_N_BYTE_SIZE);
471     }
472     returnSpec->n.data = dataN;
473     returnSpec->n.len = RSA_2048_N_BYTE_SIZE;
474     returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
475     returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
476     return;
477 }
478 
GenerateRsa2048CorrectPubKeySpec(unsigned char * dataN,unsigned char * dataE,HcfRsaPubKeyParamsSpec * returnPubSpec)479 static void GenerateRsa2048CorrectPubKeySpec(unsigned char *dataN, unsigned char *dataE,
480     HcfRsaPubKeyParamsSpec *returnPubSpec)
481 {
482     HcfRsaCommParamsSpec rsaCommSpec = {};
483     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
484     RemoveLastChar(RSA_2048_CORRECT_E, dataE, RSA_2048_E_BYTE_SIZE);
485     if (!IsBigEndian()) {
486         // the device is not big endian
487         EndianSwap(dataE, 0, RSA_2048_E_BYTE_SIZE);
488     }
489     returnPubSpec->pk.data = dataE;
490     returnPubSpec->pk.len = RSA_2048_E_BYTE_SIZE;
491     returnPubSpec->base = rsaCommSpec;
492     returnPubSpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
493 }
494 
GenerateRsa2048CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)495 static void GenerateRsa2048CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
496     HcfRsaKeyPairParamsSpec *returnPairSpec)
497 {
498     HcfRsaCommParamsSpec rsaCommSpec = {};
499     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
500     RemoveLastChar(RSA_2048_CORRECT_E, dataE, RSA_2048_E_BYTE_SIZE);
501     RemoveLastChar(RSA_2048_CORRECT_D, dataD, RSA_2048_D_BYTE_SIZE);
502     if (!IsBigEndian()) {
503         // the device is not big endian
504         EndianSwap(dataE, 0, RSA_2048_E_BYTE_SIZE);
505         EndianSwap(dataD, 0, RSA_2048_D_BYTE_SIZE);
506     }
507     returnPairSpec->pk.data = dataE;
508     returnPairSpec->pk.len = RSA_2048_E_BYTE_SIZE;
509     returnPairSpec->sk.data = dataD;
510     returnPairSpec->sk.len = RSA_2048_D_BYTE_SIZE;
511     returnPairSpec->base = rsaCommSpec;
512     returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
513 }
514 
515 // ECC spec
516 static string g_eccAlgName = "ECC";
517 static string g_eccFieldType = "Fp";
518 static int32_t g_ecc224CorrectH = 1;
519 
ConstructEcc224CommParamsSpec(HcfEccCommParamsSpec ** spec)520 static HcfResult ConstructEcc224CommParamsSpec(HcfEccCommParamsSpec **spec)
521 {
522     HcfEccCommParamsSpec *eccCommSpec =
523         reinterpret_cast<HcfEccCommParamsSpec *>(HcfMalloc(sizeof(HcfEccCommParamsSpec), 0));
524     if (eccCommSpec == nullptr) {
525         return HCF_ERR_MALLOC;
526     }
527     HcfECFieldFp *tmpField = reinterpret_cast<HcfECFieldFp *>(HcfMalloc(sizeof(HcfECFieldFp), 0));
528     if (tmpField == nullptr) {
529         HcfFree(eccCommSpec);
530         return HCF_ERR_MALLOC;
531     }
532 
533     eccCommSpec->base.algName = const_cast<char *>(g_eccAlgName.c_str());
534     eccCommSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
535     eccCommSpec->field = reinterpret_cast<HcfECField *>(tmpField);
536     eccCommSpec->field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
537     ((HcfECFieldFp *)(eccCommSpec->field))->p.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP);
538     ((HcfECFieldFp *)(eccCommSpec->field))->p.len = NID_secp224r1_len;
539     eccCommSpec->a.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA);
540     eccCommSpec->a.len = NID_secp224r1_len;
541     eccCommSpec->b.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigB : g_ecc224CorrectLittleB);
542     eccCommSpec->b.len = NID_secp224r1_len;
543     eccCommSpec->g.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX);
544     eccCommSpec->g.x.len = NID_secp224r1_len;
545     eccCommSpec->g.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY);
546     eccCommSpec->g.y.len = NID_secp224r1_len;
547     eccCommSpec->n.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN);
548     eccCommSpec->n.len = NID_secp224r1_len;
549     eccCommSpec->h = g_ecc224CorrectH;
550 
551     *spec = eccCommSpec;
552     return HCF_SUCCESS;
553 }
554 
ConstructEcc224PubKeyParamsSpec(HcfEccPubKeyParamsSpec ** spec)555 static HcfResult ConstructEcc224PubKeyParamsSpec(HcfEccPubKeyParamsSpec **spec)
556 {
557     HcfEccPubKeyParamsSpec *eccPubKeySpec =
558         reinterpret_cast<HcfEccPubKeyParamsSpec *>(HcfMalloc(sizeof(HcfEccPubKeyParamsSpec), 0));
559     if (eccPubKeySpec == nullptr) {
560         return HCF_ERR_MALLOC;
561     }
562     HcfECFieldFp *tmpField = reinterpret_cast<HcfECFieldFp *>(HcfMalloc(sizeof(HcfECFieldFp), 0));
563     if (tmpField == nullptr) {
564         HcfFree(eccPubKeySpec);
565         return HCF_ERR_MALLOC;
566     }
567 
568     eccPubKeySpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
569     eccPubKeySpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
570     eccPubKeySpec->base.field = reinterpret_cast<HcfECField *>(tmpField);
571     eccPubKeySpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
572     ((HcfECFieldFp *)(eccPubKeySpec->base.field))->p.data =
573         (IS_BIG_ENDIAN ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP);
574     ((HcfECFieldFp *)(eccPubKeySpec->base.field))->p.len = NID_secp224r1_len;
575     eccPubKeySpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA);
576     eccPubKeySpec->base.a.len = NID_secp224r1_len;
577     eccPubKeySpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigB : g_ecc224CorrectLittleB);
578     eccPubKeySpec->base.b.len = NID_secp224r1_len;
579     eccPubKeySpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX);
580     eccPubKeySpec->base.g.x.len = NID_secp224r1_len;
581     eccPubKeySpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY);
582     eccPubKeySpec->base.g.y.len = NID_secp224r1_len;
583     eccPubKeySpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN);
584     eccPubKeySpec->base.n.len = NID_secp224r1_len;
585     eccPubKeySpec->base.h = g_ecc224CorrectH;
586     eccPubKeySpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigPkX : g_ecc224CorrectLittlePkX);
587     eccPubKeySpec->pk.x.len = NID_secp224r1_len;
588     eccPubKeySpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigPkY : g_ecc224CorrectLittlePkY);
589     eccPubKeySpec->pk.y.len = NID_secp224r1_len;
590 
591     *spec = eccPubKeySpec;
592     return HCF_SUCCESS;
593 }
594 
ConstructEcc224PriKeyParamsSpec(HcfEccPriKeyParamsSpec ** spec)595 static HcfResult ConstructEcc224PriKeyParamsSpec(HcfEccPriKeyParamsSpec **spec)
596 {
597     HcfEccPriKeyParamsSpec *eccPriKeySpec =
598         reinterpret_cast<HcfEccPriKeyParamsSpec *>(HcfMalloc(sizeof(HcfEccPriKeyParamsSpec), 0));
599     if (eccPriKeySpec == nullptr) {
600         return HCF_ERR_MALLOC;
601     }
602     HcfECFieldFp *tmpField = reinterpret_cast<HcfECFieldFp *>(HcfMalloc(sizeof(HcfECFieldFp), 0));
603     if (tmpField == nullptr) {
604         HcfFree(eccPriKeySpec);
605         return HCF_ERR_MALLOC;
606     }
607 
608     eccPriKeySpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
609     eccPriKeySpec->base.base.specType = HCF_PRIVATE_KEY_SPEC;
610     eccPriKeySpec->base.field = reinterpret_cast<HcfECField *>(tmpField);
611     eccPriKeySpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
612     ((HcfECFieldFp *)(eccPriKeySpec->base.field))->p.data =
613         (IS_BIG_ENDIAN ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP);
614     ((HcfECFieldFp *)(eccPriKeySpec->base.field))->p.len = NID_secp224r1_len;
615     eccPriKeySpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA);
616     eccPriKeySpec->base.a.len = NID_secp224r1_len;
617     eccPriKeySpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigB : g_ecc224CorrectLittleB);
618     eccPriKeySpec->base.b.len = NID_secp224r1_len;
619     eccPriKeySpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX);
620     eccPriKeySpec->base.g.x.len = NID_secp224r1_len;
621     eccPriKeySpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY);
622     eccPriKeySpec->base.g.y.len = NID_secp224r1_len;
623     eccPriKeySpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN);
624     eccPriKeySpec->base.n.len = NID_secp224r1_len;
625     eccPriKeySpec->base.h = g_ecc224CorrectH;
626     eccPriKeySpec->sk.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigSk : g_ecc224CorrectLittleSk);
627     eccPriKeySpec->sk.len = NID_secp224r1_len;
628 
629     *spec = eccPriKeySpec;
630     return HCF_SUCCESS;
631 }
632 
ConstructEcc224KeyPairParamsSpec(HcfEccKeyPairParamsSpec ** spec)633 static HcfResult ConstructEcc224KeyPairParamsSpec(HcfEccKeyPairParamsSpec **spec)
634 {
635     HcfEccKeyPairParamsSpec *eccKeyPairSpec =
636         reinterpret_cast<HcfEccKeyPairParamsSpec *>(HcfMalloc(sizeof(HcfEccKeyPairParamsSpec), 0));
637     if (eccKeyPairSpec == nullptr) {
638         return HCF_ERR_MALLOC;
639     }
640     HcfECFieldFp *tmpField = reinterpret_cast<HcfECFieldFp *>(HcfMalloc(sizeof(HcfECFieldFp), 0));
641     if (tmpField == nullptr) {
642         HcfFree(eccKeyPairSpec);
643         return HCF_ERR_MALLOC;
644     }
645 
646     eccKeyPairSpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
647     eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
648     eccKeyPairSpec->base.field = reinterpret_cast<HcfECField *>(tmpField);
649     eccKeyPairSpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
650     ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data =
651         (IS_BIG_ENDIAN ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP);
652     ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_secp224r1_len;
653     eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA);
654     eccKeyPairSpec->base.a.len = NID_secp224r1_len;
655     eccKeyPairSpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigB : g_ecc224CorrectLittleB);
656     eccKeyPairSpec->base.b.len = NID_secp224r1_len;
657     eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX);
658     eccKeyPairSpec->base.g.x.len = NID_secp224r1_len;
659     eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY);
660     eccKeyPairSpec->base.g.y.len = NID_secp224r1_len;
661     eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN);
662     eccKeyPairSpec->base.n.len = NID_secp224r1_len;
663     eccKeyPairSpec->base.h = g_ecc224CorrectH;
664     eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigPkX : g_ecc224CorrectLittlePkX);
665     eccKeyPairSpec->pk.x.len = NID_secp224r1_len;
666     eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigPkY : g_ecc224CorrectLittlePkY);
667     eccKeyPairSpec->pk.y.len = NID_secp224r1_len;
668     eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigSk : g_ecc224CorrectLittleSk);
669     eccKeyPairSpec->sk.len = NID_secp224r1_len;
670 
671     *spec = eccKeyPairSpec;
672     return HCF_SUCCESS;
673 }
674 
FreeEccCommSpec(HcfEccCommParamsSpec * spec)675 static void FreeEccCommSpec(HcfEccCommParamsSpec *spec)
676 {
677     HcfFree(reinterpret_cast<HcfECFieldFp *>(spec->field));
678     HcfFree(spec);
679 }
680 
FreeEccPubSpec(HcfEccPubKeyParamsSpec * spec)681 static void FreeEccPubSpec(HcfEccPubKeyParamsSpec *spec)
682 {
683     HcfFree(reinterpret_cast<HcfECFieldFp *>(spec->base.field));
684     HcfFree(spec);
685 }
686 
FreeEccPriSpec(HcfEccPriKeyParamsSpec * spec)687 static void FreeEccPriSpec(HcfEccPriKeyParamsSpec *spec)
688 {
689     HcfFree(reinterpret_cast<HcfECFieldFp *>(spec->base.field));
690     HcfFree(spec);
691 }
692 
FreeEccKeyPairSpec(HcfEccKeyPairParamsSpec * spec)693 static void FreeEccKeyPairSpec(HcfEccKeyPairParamsSpec *spec)
694 {
695     HcfFree(reinterpret_cast<HcfECFieldFp *>(spec->base.field));
696     HcfFree(spec);
697 }
698 
699 // invalid DSA comm spec
700 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest001, TestSize.Level0)
701 {
702     HcfAsyKeyGeneratorBySpec *generator = nullptr;
703     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpecNoAlg),
704         &generator);
705     EXPECT_NE(ret, HCF_SUCCESS);
706     EXPECT_EQ(generator, nullptr);
707 }
708 
709 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest002, TestSize.Level0)
710 {
711     HcfAsyKeyGeneratorBySpec *generator = nullptr;
712     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpecErrorAlg),
713         &generator);
714     EXPECT_NE(ret, HCF_SUCCESS);
715     EXPECT_EQ(generator, nullptr);
716 }
717 
718 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest003, TestSize.Level0)
719 {
720     HcfAsyKeyGeneratorBySpec *generator = nullptr;
721     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpecNullG),
722         &generator);
723     EXPECT_NE(ret, HCF_SUCCESS);
724     EXPECT_EQ(generator, nullptr);
725 }
726 
727 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest004, TestSize.Level0)
728 {
729     HcfAsyKeyGeneratorBySpec *generator = nullptr;
730     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpecNullP),
731         &generator);
732     EXPECT_NE(ret, HCF_SUCCESS);
733     EXPECT_EQ(generator, nullptr);
734 }
735 
736 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest005, TestSize.Level0)
737 {
738     HcfAsyKeyGeneratorBySpec *generator = nullptr;
739     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpecNullQ),
740         &generator);
741     EXPECT_NE(ret, HCF_SUCCESS);
742     EXPECT_EQ(generator, nullptr);
743 }
744 
745 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest006, TestSize.Level0)
746 {
747     HcfAsyKeyGeneratorBySpec *generator = nullptr;
748     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpecNoLenG),
749         &generator);
750     EXPECT_NE(ret, HCF_SUCCESS);
751     EXPECT_EQ(generator, nullptr);
752 }
753 
754 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest007, TestSize.Level0)
755 {
756     HcfAsyKeyGeneratorBySpec *generator = nullptr;
757     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpecNoLenP),
758         &generator);
759     EXPECT_NE(ret, HCF_SUCCESS);
760     EXPECT_EQ(generator, nullptr);
761 }
762 
763 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest008, TestSize.Level0)
764 {
765     HcfAsyKeyGeneratorBySpec *generator = nullptr;
766     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpecNoLenQ),
767         &generator);
768     EXPECT_NE(ret, HCF_SUCCESS);
769     EXPECT_EQ(generator, nullptr);
770 }
771 
772 // invalid DSA pub spec
773 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest009, TestSize.Level0)
774 {
775     HcfAsyKeyGeneratorBySpec *generator = nullptr;
776     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpecErrorComm),
777         &generator);
778     EXPECT_NE(ret, HCF_SUCCESS);
779     EXPECT_EQ(generator, nullptr);
780 }
781 
782 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest010, TestSize.Level0)
783 {
784     HcfAsyKeyGeneratorBySpec *generator = nullptr;
785     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpecNoLenPk),
786         &generator);
787     EXPECT_NE(ret, HCF_SUCCESS);
788     EXPECT_EQ(generator, nullptr);
789 }
790 
791 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest011, TestSize.Level0)
792 {
793     HcfAsyKeyGeneratorBySpec *generator = nullptr;
794     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpecNullPk),
795         &generator);
796     EXPECT_NE(ret, HCF_SUCCESS);
797     EXPECT_EQ(generator, nullptr);
798 }
799 
800 // invalid DSA keyPair spec
801 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest012, TestSize.Level0)
802 {
803     HcfAsyKeyGeneratorBySpec *generator = nullptr;
804     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpecErrorComm),
805         &generator);
806     EXPECT_NE(ret, HCF_SUCCESS);
807     EXPECT_EQ(generator, nullptr);
808 }
809 
810 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest013, TestSize.Level0)
811 {
812     HcfAsyKeyGeneratorBySpec *generator = nullptr;
813     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(
814         reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpecErrorSpecType), &generator);
815     EXPECT_NE(ret, HCF_SUCCESS);
816     EXPECT_EQ(generator, nullptr);
817 }
818 
819 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest014, TestSize.Level0)
820 {
821     HcfAsyKeyGeneratorBySpec *generator = nullptr;
822     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpecNoLenPk),
823         &generator);
824     EXPECT_NE(ret, HCF_SUCCESS);
825     EXPECT_EQ(generator, nullptr);
826 }
827 
828 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest015, TestSize.Level0)
829 {
830     HcfAsyKeyGeneratorBySpec *generator = nullptr;
831     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpecNullPk),
832         &generator);
833     EXPECT_NE(ret, HCF_SUCCESS);
834     EXPECT_EQ(generator, nullptr);
835 }
836 
837 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest016, TestSize.Level0)
838 {
839     HcfAsyKeyGeneratorBySpec *generator = nullptr;
840     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpecNoLenSk),
841         &generator);
842     EXPECT_NE(ret, HCF_SUCCESS);
843     EXPECT_EQ(generator, nullptr);
844 }
845 
846 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest017, TestSize.Level0)
847 {
848     HcfAsyKeyGeneratorBySpec *generator = nullptr;
849     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpecNullSk),
850         &generator);
851     EXPECT_NE(ret, HCF_SUCCESS);
852     EXPECT_EQ(generator, nullptr);
853 }
854 
855 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest018, TestSize.Level0)
856 {
857     FreeAsyKeySpec(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpecErrorSpecType));
858     EXPECT_NE(dsaKeyPairSpecErrorSpecType.base.base.algName, nullptr);
859 }
860 
861 // invalid RSA spec type
862 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest101, TestSize.Level0)
863 {
864     HcfRsaCommParamsSpec rsaCommSpec = {};
865     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
866     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
867     rsaCommSpec.base.specType = HCF_PRIVATE_KEY_SPEC;
868 
869     HcfAsyKeyGeneratorBySpec *generator = nullptr;
870     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec), &generator);
871     EXPECT_NE(res, HCF_SUCCESS);
872     EXPECT_EQ(generator, nullptr);
873 
874     HcfObjDestroy(generator);
875 }
876 
877 // invalid RSA comm spec
878 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest102, TestSize.Level0)
879 {
880     HcfRsaCommParamsSpec rsaCommSpec = {};
881     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
882     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
883     rsaCommSpec.n.data = nullptr;
884 
885     HcfAsyKeyGeneratorBySpec *generator = nullptr;
886     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec), &generator);
887     EXPECT_NE(res, HCF_SUCCESS);
888     EXPECT_EQ(generator, nullptr);
889 
890     HcfObjDestroy(generator);
891 }
892 
893 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest103, TestSize.Level0)
894 {
895     HcfRsaCommParamsSpec rsaCommSpec = {};
896     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
897     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
898     rsaCommSpec.n.len = 0;
899 
900     HcfAsyKeyGeneratorBySpec *generator = nullptr;
901     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec), &generator);
902     EXPECT_NE(res, HCF_SUCCESS);
903     EXPECT_EQ(generator, nullptr);
904 
905     HcfObjDestroy(generator);
906 }
907 
908 // invalid RSA pubKey spec
909 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest104, TestSize.Level0)
910 {
911     HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
912     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
913     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
914     GenerateRsa2048CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
915     rsaPubKeySpec.base.n.data = nullptr;
916 
917     HcfAsyKeyGeneratorBySpec *generator = nullptr;
918     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
919     EXPECT_NE(res, HCF_SUCCESS);
920     EXPECT_EQ(generator, nullptr);
921 
922     HcfObjDestroy(generator);
923 }
924 
925 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest105, TestSize.Level0)
926 {
927     HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
928     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
929     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
930     GenerateRsa2048CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
931     rsaPubKeySpec.pk.data = nullptr;
932 
933     HcfAsyKeyGeneratorBySpec *generator = nullptr;
934     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
935     EXPECT_NE(res, HCF_SUCCESS);
936     EXPECT_EQ(generator, nullptr);
937 
938     HcfObjDestroy(generator);
939 }
940 
941 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest106, TestSize.Level0)
942 {
943     HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
944     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
945     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
946     GenerateRsa2048CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
947     rsaPubKeySpec.pk.len = 0;
948 
949     HcfAsyKeyGeneratorBySpec *generator = nullptr;
950     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
951     EXPECT_NE(res, HCF_SUCCESS);
952     EXPECT_EQ(generator, nullptr);
953 
954     HcfObjDestroy(generator);
955 }
956 
957 // invalid RSA keyPair spec
958 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest107, TestSize.Level0)
959 {
960     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
961     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
962     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
963     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
964     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
965     rsaPairSpec.base.n.data = nullptr;
966 
967     HcfAsyKeyGeneratorBySpec *generator = nullptr;
968     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
969     EXPECT_NE(res, HCF_SUCCESS);
970     EXPECT_EQ(generator, nullptr);
971 
972     HcfObjDestroy(generator);
973 }
974 
975 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest108, TestSize.Level0)
976 {
977     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
978     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
979     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
980     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
981     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
982     rsaPairSpec.pk.data = nullptr;
983 
984     HcfAsyKeyGeneratorBySpec *generator = nullptr;
985     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
986     EXPECT_NE(res, HCF_SUCCESS);
987     EXPECT_EQ(generator, nullptr);
988 
989     HcfObjDestroy(generator);
990 }
991 
992 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest109, TestSize.Level0)
993 {
994     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
995     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
996     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
997     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
998     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
999     rsaPairSpec.pk.len = 0;
1000 
1001     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1002     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1003     EXPECT_NE(res, HCF_SUCCESS);
1004     EXPECT_EQ(generator, nullptr);
1005 
1006     HcfObjDestroy(generator);
1007 }
1008 
1009 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest110, TestSize.Level0)
1010 {
1011     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1012     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1013     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1014     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1015     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1016     rsaPairSpec.sk.data = nullptr;
1017 
1018     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1019     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1020     EXPECT_NE(res, HCF_SUCCESS);
1021     EXPECT_EQ(generator, nullptr);
1022 
1023     HcfObjDestroy(generator);
1024 }
1025 
1026 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest111, TestSize.Level0)
1027 {
1028     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1029     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1030     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1031     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1032     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1033     rsaPairSpec.sk.len = 0;
1034 
1035     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1036     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1037     EXPECT_NE(res, HCF_SUCCESS);
1038     EXPECT_EQ(generator, nullptr);
1039 
1040     HcfObjDestroy(generator);
1041 }
1042 
1043 // invalid RSA free
1044 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest112, TestSize.Level0)
1045 {
1046     HcfRsaCommParamsSpec rsaCommSpec = {};
1047     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1048     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
1049 
1050     rsaCommSpec.base.specType = HCF_PRIVATE_KEY_SPEC;
1051     FreeAsyKeySpec(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec));
1052     EXPECT_NE(rsaCommSpec.base.algName, nullptr);
1053 }
1054 
1055 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest113, TestSize.Level0)
1056 {
1057     HcfRsaCommParamsSpec rsaCommSpec = {};
1058     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1059     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
1060 
1061     rsaCommSpec.base.algName = const_cast<char *>(g_invalidAlgName);
1062     FreeAsyKeySpec(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec));
1063     EXPECT_NE(rsaCommSpec.base.algName, nullptr);
1064 }
1065 
1066 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest114, TestSize.Level0)
1067 {
1068     HcfRsaCommParamsSpec rsaCommSpec = {};
1069     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1070     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
1071 
1072     rsaCommSpec.base.specType = HCF_PRIVATE_KEY_SPEC;
1073     FreeAsyKeySpec(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec));
1074     EXPECT_NE(rsaCommSpec.base.algName, nullptr);
1075 }
1076 
1077 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest115, TestSize.Level0)
1078 {
1079     HcfRsaCommParamsSpec rsaCommSpec = {};
1080     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1081     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
1082 
1083     rsaCommSpec.base.algName = nullptr;
1084     FreeAsyKeySpec(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec));
1085     EXPECT_EQ(rsaCommSpec.base.algName, nullptr);
1086 }
1087 
1088 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest116, TestSize.Level0)
1089 {
1090     HcfRsaCommParamsSpec *rsaCommSpec = nullptr;
1091     FreeAsyKeySpec(reinterpret_cast<HcfAsyKeyParamsSpec *>(rsaCommSpec));
1092     EXPECT_EQ(rsaCommSpec, nullptr);
1093 }
1094 
1095 // invalid ECC spec type
1096 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest201, TestSize.Level0)
1097 {
1098     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1099     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1100     EXPECT_EQ(res, HCF_SUCCESS);
1101 
1102     eccCommSpec->base.specType = HcfAsyKeySpecType(INVALID_SPEC_TYPE);
1103     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1104     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1105     EXPECT_NE(res, HCF_SUCCESS);
1106     EXPECT_EQ(generator, nullptr);
1107 
1108     FreeEccCommSpec(eccCommSpec);
1109     HcfObjDestroy(generator);
1110 }
1111 
1112 // invalid ECC Comm spec
1113 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest202, TestSize.Level0)
1114 {
1115     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1116     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1117     EXPECT_EQ(res, HCF_SUCCESS);
1118 
1119     eccCommSpec->a.data = nullptr;
1120     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1121     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1122     EXPECT_NE(res, HCF_SUCCESS);
1123     EXPECT_EQ(generator, nullptr);
1124 
1125     FreeEccCommSpec(eccCommSpec);
1126     HcfObjDestroy(generator);
1127 }
1128 
1129 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest203, TestSize.Level0)
1130 {
1131     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1132     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1133     EXPECT_EQ(res, HCF_SUCCESS);
1134 
1135     eccCommSpec->a.len = 0;
1136     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1137     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1138     EXPECT_NE(res, HCF_SUCCESS);
1139     EXPECT_EQ(generator, nullptr);
1140 
1141     FreeEccCommSpec(eccCommSpec);
1142     HcfObjDestroy(generator);
1143 }
1144 
1145 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest204, TestSize.Level0)
1146 {
1147     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1148     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1149     EXPECT_EQ(res, HCF_SUCCESS);
1150 
1151     eccCommSpec->b.data = nullptr;
1152     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1153     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1154     EXPECT_NE(res, HCF_SUCCESS);
1155     EXPECT_EQ(generator, nullptr);
1156 
1157     FreeEccCommSpec(eccCommSpec);
1158     HcfObjDestroy(generator);
1159 }
1160 
1161 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest205, TestSize.Level0)
1162 {
1163     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1164     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1165     EXPECT_EQ(res, HCF_SUCCESS);
1166 
1167     eccCommSpec->b.len = 0;
1168     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1169     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1170     EXPECT_NE(res, HCF_SUCCESS);
1171     EXPECT_EQ(generator, nullptr);
1172 
1173     FreeEccCommSpec(eccCommSpec);
1174     HcfObjDestroy(generator);
1175 }
1176 
1177 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest206, TestSize.Level0)
1178 {
1179     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1180     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1181     EXPECT_EQ(res, HCF_SUCCESS);
1182 
1183     eccCommSpec->n.data = nullptr;
1184     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1185     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1186     EXPECT_NE(res, HCF_SUCCESS);
1187     EXPECT_EQ(generator, nullptr);
1188 
1189     FreeEccCommSpec(eccCommSpec);
1190     HcfObjDestroy(generator);
1191 }
1192 
1193 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest207, TestSize.Level0)
1194 {
1195     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1196     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1197     EXPECT_EQ(res, HCF_SUCCESS);
1198 
1199     eccCommSpec->n.len = 0;
1200     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1201     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1202     EXPECT_NE(res, HCF_SUCCESS);
1203     EXPECT_EQ(generator, nullptr);
1204 
1205     FreeEccCommSpec(eccCommSpec);
1206     HcfObjDestroy(generator);
1207 }
1208 
1209 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest208, TestSize.Level0)
1210 {
1211     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1212     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1213     EXPECT_EQ(res, HCF_SUCCESS);
1214 
1215     eccCommSpec->g.x.data = nullptr;
1216     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1217     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1218     EXPECT_NE(res, HCF_SUCCESS);
1219     EXPECT_EQ(generator, nullptr);
1220 
1221     FreeEccCommSpec(eccCommSpec);
1222     HcfObjDestroy(generator);
1223 }
1224 
1225 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest209, TestSize.Level0)
1226 {
1227     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1228     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1229     EXPECT_EQ(res, HCF_SUCCESS);
1230 
1231     eccCommSpec->g.x.len = 0;
1232     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1233     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1234     EXPECT_NE(res, HCF_SUCCESS);
1235     EXPECT_EQ(generator, nullptr);
1236 
1237     FreeEccCommSpec(eccCommSpec);
1238     HcfObjDestroy(generator);
1239 }
1240 
1241 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest210, TestSize.Level0)
1242 {
1243     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1244     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1245     EXPECT_EQ(res, HCF_SUCCESS);
1246 
1247     eccCommSpec->g.y.data = nullptr;
1248     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1249     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1250     EXPECT_NE(res, HCF_SUCCESS);
1251     EXPECT_EQ(generator, nullptr);
1252 
1253     FreeEccCommSpec(eccCommSpec);
1254     HcfObjDestroy(generator);
1255 }
1256 
1257 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest211, TestSize.Level0)
1258 {
1259     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1260     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1261     EXPECT_EQ(res, HCF_SUCCESS);
1262 
1263     eccCommSpec->g.y.len = 0;
1264     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1265     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1266     EXPECT_NE(res, HCF_SUCCESS);
1267     EXPECT_EQ(generator, nullptr);
1268 
1269     FreeEccCommSpec(eccCommSpec);
1270     HcfObjDestroy(generator);
1271 }
1272 
1273 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest212, TestSize.Level0)
1274 {
1275     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1276     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1277     EXPECT_EQ(res, HCF_SUCCESS);
1278 
1279     HcfFree(eccCommSpec->field);
1280     eccCommSpec->field = nullptr;
1281     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1282     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1283     EXPECT_NE(res, HCF_SUCCESS);
1284     EXPECT_EQ(generator, nullptr);
1285 
1286     FreeEccCommSpec(eccCommSpec);
1287     HcfObjDestroy(generator);
1288 }
1289 
1290 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest213, TestSize.Level0)
1291 {
1292     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1293     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1294     EXPECT_EQ(res, HCF_SUCCESS);
1295 
1296     eccCommSpec->field->fieldType = const_cast<char *>(g_eccAlgName.c_str());
1297     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1298     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1299     EXPECT_NE(res, HCF_SUCCESS);
1300     EXPECT_EQ(generator, nullptr);
1301 
1302     FreeEccCommSpec(eccCommSpec);
1303     HcfObjDestroy(generator);
1304 }
1305 
1306 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest214, TestSize.Level0)
1307 {
1308     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1309     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1310     EXPECT_EQ(res, HCF_SUCCESS);
1311 
1312     HcfECFieldFp *tmp = reinterpret_cast<HcfECFieldFp *>(eccCommSpec->field);
1313     tmp->p.data = nullptr;
1314     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1315     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1316     EXPECT_NE(res, HCF_SUCCESS);
1317     EXPECT_EQ(generator, nullptr);
1318 
1319     FreeEccCommSpec(eccCommSpec);
1320     HcfObjDestroy(generator);
1321 }
1322 
1323 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest215, TestSize.Level0)
1324 {
1325     HcfEccCommParamsSpec *eccCommSpec = nullptr;
1326     HcfResult res = ConstructEcc224CommParamsSpec(&eccCommSpec);
1327     EXPECT_EQ(res, HCF_SUCCESS);
1328 
1329     HcfECFieldFp *tmp = reinterpret_cast<HcfECFieldFp *>(eccCommSpec->field);
1330     tmp->p.len = 0;
1331     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1332     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1333     EXPECT_NE(res, HCF_SUCCESS);
1334     EXPECT_EQ(generator, nullptr);
1335 
1336     FreeEccCommSpec(eccCommSpec);
1337     HcfObjDestroy(generator);
1338 }
1339 
1340 // invalid ECC pubKey spec
1341 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest216, TestSize.Level0)
1342 {
1343     HcfEccPubKeyParamsSpec *eccPubSpec = nullptr;
1344     HcfResult res = ConstructEcc224PubKeyParamsSpec(&eccPubSpec);
1345     EXPECT_EQ(res, HCF_SUCCESS);
1346 
1347     eccPubSpec->base.a.data = nullptr;
1348     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1349     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPubSpec), &generator);
1350     EXPECT_NE(res, HCF_SUCCESS);
1351     EXPECT_EQ(generator, nullptr);
1352 
1353     FreeEccPubSpec(eccPubSpec);
1354     HcfObjDestroy(generator);
1355 }
1356 
1357 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest217, TestSize.Level0)
1358 {
1359     HcfEccPubKeyParamsSpec *eccPubSpec = nullptr;
1360     HcfResult res = ConstructEcc224PubKeyParamsSpec(&eccPubSpec);
1361     EXPECT_EQ(res, HCF_SUCCESS);
1362 
1363     eccPubSpec->pk.x.data = nullptr;
1364     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1365     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPubSpec), &generator);
1366     EXPECT_NE(res, HCF_SUCCESS);
1367     EXPECT_EQ(generator, nullptr);
1368 
1369     FreeEccPubSpec(eccPubSpec);
1370     HcfObjDestroy(generator);
1371 }
1372 
1373 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest218, TestSize.Level0)
1374 {
1375     HcfEccPubKeyParamsSpec *eccPubSpec = nullptr;
1376     HcfResult res = ConstructEcc224PubKeyParamsSpec(&eccPubSpec);
1377     EXPECT_EQ(res, HCF_SUCCESS);
1378 
1379     eccPubSpec->pk.x.len = 0;
1380     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1381     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPubSpec), &generator);
1382     EXPECT_NE(res, HCF_SUCCESS);
1383     EXPECT_EQ(generator, nullptr);
1384 
1385     FreeEccPubSpec(eccPubSpec);
1386     HcfObjDestroy(generator);
1387 }
1388 
1389 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest219, TestSize.Level0)
1390 {
1391     HcfEccPubKeyParamsSpec *eccPubSpec = nullptr;
1392     HcfResult res = ConstructEcc224PubKeyParamsSpec(&eccPubSpec);
1393     EXPECT_EQ(res, HCF_SUCCESS);
1394 
1395     eccPubSpec->pk.y.data = nullptr;
1396     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1397     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPubSpec), &generator);
1398     EXPECT_NE(res, HCF_SUCCESS);
1399     EXPECT_EQ(generator, nullptr);
1400 
1401     FreeEccPubSpec(eccPubSpec);
1402     HcfObjDestroy(generator);
1403 }
1404 
1405 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest220, TestSize.Level0)
1406 {
1407     HcfEccPubKeyParamsSpec *eccPubSpec = nullptr;
1408     HcfResult res = ConstructEcc224PubKeyParamsSpec(&eccPubSpec);
1409     EXPECT_EQ(res, HCF_SUCCESS);
1410 
1411     eccPubSpec->pk.y.len = 0;
1412     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1413     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPubSpec), &generator);
1414     EXPECT_NE(res, HCF_SUCCESS);
1415     EXPECT_EQ(generator, nullptr);
1416 
1417     FreeEccPubSpec(eccPubSpec);
1418     HcfObjDestroy(generator);
1419 }
1420 
1421 // invalid ECC priKey spec
1422 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest221, TestSize.Level0)
1423 {
1424     HcfEccPriKeyParamsSpec *eccPriSpec = nullptr;
1425     HcfResult res = ConstructEcc224PriKeyParamsSpec(&eccPriSpec);
1426     EXPECT_EQ(res, HCF_SUCCESS);
1427 
1428     eccPriSpec->base.a.data = nullptr;
1429     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1430     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPriSpec), &generator);
1431     EXPECT_NE(res, HCF_SUCCESS);
1432     EXPECT_EQ(generator, nullptr);
1433 
1434     FreeEccPriSpec(eccPriSpec);
1435     HcfObjDestroy(generator);
1436 }
1437 
1438 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest222, TestSize.Level0)
1439 {
1440     HcfEccPriKeyParamsSpec *eccPriSpec = nullptr;
1441     HcfResult res = ConstructEcc224PriKeyParamsSpec(&eccPriSpec);
1442     EXPECT_EQ(res, HCF_SUCCESS);
1443 
1444     eccPriSpec->sk.data = nullptr;
1445     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1446     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPriSpec), &generator);
1447     EXPECT_NE(res, HCF_SUCCESS);
1448     EXPECT_EQ(generator, nullptr);
1449 
1450     FreeEccPriSpec(eccPriSpec);
1451     HcfObjDestroy(generator);
1452 }
1453 
1454 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest223, TestSize.Level0)
1455 {
1456     HcfEccPriKeyParamsSpec *eccPriSpec = nullptr;
1457     HcfResult res = ConstructEcc224PriKeyParamsSpec(&eccPriSpec);
1458     EXPECT_EQ(res, HCF_SUCCESS);
1459 
1460     eccPriSpec->sk.len = 0;
1461     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1462     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPriSpec), &generator);
1463     EXPECT_NE(res, HCF_SUCCESS);
1464     EXPECT_EQ(generator, nullptr);
1465 
1466     FreeEccPriSpec(eccPriSpec);
1467     HcfObjDestroy(generator);
1468 }
1469 
1470 // invalid ECC keyPair spec
1471 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest224, TestSize.Level0)
1472 {
1473     HcfEccKeyPairParamsSpec *eccKeyPairSpec = nullptr;
1474     HcfResult res = ConstructEcc224KeyPairParamsSpec(&eccKeyPairSpec);
1475     EXPECT_EQ(res, HCF_SUCCESS);
1476 
1477     eccKeyPairSpec->base.a.data = nullptr;
1478     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1479     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccKeyPairSpec), &generator);
1480     EXPECT_NE(res, HCF_SUCCESS);
1481     EXPECT_EQ(generator, nullptr);
1482 
1483     FreeEccKeyPairSpec(eccKeyPairSpec);
1484     HcfObjDestroy(generator);
1485 }
1486 
1487 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest225, TestSize.Level0)
1488 {
1489     HcfEccKeyPairParamsSpec *eccKeyPairSpec = nullptr;
1490     HcfResult res = ConstructEcc224KeyPairParamsSpec(&eccKeyPairSpec);
1491     EXPECT_EQ(res, HCF_SUCCESS);
1492 
1493     eccKeyPairSpec->pk.x.data = nullptr;
1494     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1495     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccKeyPairSpec), &generator);
1496     EXPECT_NE(res, HCF_SUCCESS);
1497     EXPECT_EQ(generator, nullptr);
1498 
1499     FreeEccKeyPairSpec(eccKeyPairSpec);
1500     HcfObjDestroy(generator);
1501 }
1502 
1503 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest226, TestSize.Level0)
1504 {
1505     HcfEccKeyPairParamsSpec *eccKeyPairSpec = nullptr;
1506     HcfResult res = ConstructEcc224KeyPairParamsSpec(&eccKeyPairSpec);
1507     EXPECT_EQ(res, HCF_SUCCESS);
1508 
1509     eccKeyPairSpec->pk.x.len = 0;
1510     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1511     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccKeyPairSpec), &generator);
1512     EXPECT_NE(res, HCF_SUCCESS);
1513     EXPECT_EQ(generator, nullptr);
1514 
1515     FreeEccKeyPairSpec(eccKeyPairSpec);
1516     HcfObjDestroy(generator);
1517 }
1518 
1519 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest227, TestSize.Level0)
1520 {
1521     HcfEccKeyPairParamsSpec *eccKeyPairSpec = nullptr;
1522     HcfResult res = ConstructEcc224KeyPairParamsSpec(&eccKeyPairSpec);
1523     EXPECT_EQ(res, HCF_SUCCESS);
1524 
1525     eccKeyPairSpec->pk.y.data = nullptr;
1526     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1527     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccKeyPairSpec), &generator);
1528     EXPECT_NE(res, HCF_SUCCESS);
1529     EXPECT_EQ(generator, nullptr);
1530 
1531     FreeEccKeyPairSpec(eccKeyPairSpec);
1532     HcfObjDestroy(generator);
1533 }
1534 
1535 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest228, TestSize.Level0)
1536 {
1537     HcfEccKeyPairParamsSpec *eccKeyPairSpec = nullptr;
1538     HcfResult res = ConstructEcc224KeyPairParamsSpec(&eccKeyPairSpec);
1539     EXPECT_EQ(res, HCF_SUCCESS);
1540 
1541     eccKeyPairSpec->pk.y.len = 0;
1542     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1543     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccKeyPairSpec), &generator);
1544     EXPECT_NE(res, HCF_SUCCESS);
1545     EXPECT_EQ(generator, nullptr);
1546 
1547     FreeEccKeyPairSpec(eccKeyPairSpec);
1548     HcfObjDestroy(generator);
1549 }
1550 
1551 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest229, TestSize.Level0)
1552 {
1553     HcfEccKeyPairParamsSpec *eccKeyPairSpec = nullptr;
1554     HcfResult res = ConstructEcc224KeyPairParamsSpec(&eccKeyPairSpec);
1555     EXPECT_EQ(res, HCF_SUCCESS);
1556 
1557     eccKeyPairSpec->sk.data = nullptr;
1558     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1559     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccKeyPairSpec), &generator);
1560     EXPECT_NE(res, HCF_SUCCESS);
1561     EXPECT_EQ(generator, nullptr);
1562 
1563     FreeEccKeyPairSpec(eccKeyPairSpec);
1564     HcfObjDestroy(generator);
1565 }
1566 
1567 HWTEST_F(CryptoAsyKeyGeneratorCovTest, CryptoAsyKeyGeneratorTest230, TestSize.Level0)
1568 {
1569     HcfEccKeyPairParamsSpec *eccKeyPairSpec = nullptr;
1570     HcfResult res = ConstructEcc224KeyPairParamsSpec(&eccKeyPairSpec);
1571     EXPECT_EQ(res, HCF_SUCCESS);
1572 
1573     eccKeyPairSpec->sk.len = 0;
1574     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1575     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccKeyPairSpec), &generator);
1576     EXPECT_NE(res, HCF_SUCCESS);
1577     EXPECT_EQ(generator, nullptr);
1578 
1579     FreeEccKeyPairSpec(eccKeyPairSpec);
1580     HcfObjDestroy(generator);
1581 }
1582 }
1583