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 
18 #include "signature_rsa_openssl.c"
19 
20 using namespace std;
21 using namespace testing::ext;
22 
23 namespace {
24 class CryptoSignatureExceptionTest : public testing::Test {
25 public:
26     static void SetUpTestCase();
27     static void TearDownTestCase();
28     void SetUp();
29     void TearDown();
30 };
31 
SetUpTestCase()32 void CryptoSignatureExceptionTest::SetUpTestCase() {}
TearDownTestCase()33 void CryptoSignatureExceptionTest::TearDownTestCase() {}
SetUp()34 void CryptoSignatureExceptionTest::SetUp() {}
TearDown()35 void CryptoSignatureExceptionTest::TearDown() {}
36 
GetMockClass(void)37 static const char *GetMockClass(void)
38 {
39     return "HcfAsyKeyGenerator";
40 }
41 
42 HcfObjectBase g_obj = {
43     .getClass = GetMockClass,
44     .destroy = nullptr
45 };
46 
47 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest001, TestSize.Level0)
48 {
49     HcfPriKey sk;
50     HcfResult ret = EngineSignInit((HcfSignSpi *)&g_obj, nullptr, &sk);
51     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
52 
53     ret = EngineSignInit((HcfSignSpi *)&g_obj, nullptr, &sk);
54     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
55 
56     DestroyRsaSign(nullptr);
57     DestroyRsaSign((HcfObjectBase *)&g_obj);
58 
59     DestroyRsaVerify(nullptr);
60     DestroyRsaVerify((HcfObjectBase *)&g_obj);
61 }
62 
63 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest002, TestSize.Level0)
64 {
65     HcfPubKey pk;
66     HcfResult ret = EngineVerifyInit((HcfVerifySpi *)&g_obj, nullptr, &pk);
67     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
68 
69     ret = EngineVerifyInit((HcfVerifySpi *)&g_obj, nullptr, &pk);
70     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
71 }
72 
73 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest003, TestSize.Level0)
74 {
75     HcfResult ret = EngineSignUpdate((HcfSignSpi *)&g_obj, nullptr);
76     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
77 
78     ret = EngineSignUpdate(nullptr, nullptr);
79     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
80 
81     HcfBlob blob = { .data = nullptr, .len = 0 };
82     ret = EngineSignUpdate((HcfSignSpi *)&g_obj, &blob);
83     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
84 
85     uint8_t plan[] = "this is signature test!\0";
86     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
87     ret = EngineSignUpdate((HcfSignSpi *)&g_obj, &input);
88     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
89 }
90 
91 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest004, TestSize.Level0)
92 {
93     HcfResult ret = EngineVerifyUpdate((HcfVerifySpi *)&g_obj, nullptr);
94     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
95 
96     ret = EngineVerifyUpdate(nullptr, nullptr);
97     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
98 
99     HcfBlob blob = { .data = nullptr, .len = 0 };
100     ret = EngineSignUpdate((HcfSignSpi *)&g_obj, &blob);
101     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
102 
103     uint8_t plan[] = "this is verify test!\0";
104     HcfBlob output = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
105     ret = EngineSignUpdate((HcfSignSpi *)&g_obj, &output);
106     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
107 }
108 
109 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest005, TestSize.Level0)
110 {
111     HcfResult ret = EngineSign((HcfSignSpi *)&g_obj, nullptr, nullptr);
112     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
113 
114     ret = EngineSign(nullptr, nullptr, nullptr);
115     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
116 
117     HcfBlob blob = { .data = nullptr, .len = 0 };
118     ret = EngineSign((HcfSignSpi *)&g_obj, nullptr, &blob);
119     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
120 }
121 
122 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest006, TestSize.Level0)
123 {
124     bool ret = EngineVerify(nullptr, nullptr, nullptr);
125     ASSERT_EQ(ret, false);
126 
127     ret = EngineVerify((HcfVerifySpi *)&g_obj, nullptr, nullptr);
128     ASSERT_EQ(ret, false);
129 
130     HcfBlob blob = { .data = nullptr, .len = 0 };
131     ret = EngineVerify((HcfVerifySpi *)&g_obj, nullptr, &blob);
132     ASSERT_EQ(ret, false);
133 
134     uint8_t plan[] = "this is verify test!\0";
135     HcfBlob output = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
136     ret = EngineVerify((HcfVerifySpi *)&g_obj, nullptr, &output);
137     ASSERT_EQ(ret, false);
138 }
139 
140 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest007, TestSize.Level0)
141 {
142     HcfResult ret = EngineSetSignSpecInt(nullptr, PSS_SALT_LEN_INT, 0);
143     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
144 
145     ret = EngineSetSignSpecInt((HcfSignSpi *)&g_obj, PSS_SALT_LEN_INT, 0);
146     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
147 
148     HcfSign *sign = nullptr;
149     HcfResult res = HcfSignCreate("DSA1024|SHA256", &sign);
150     ASSERT_EQ(res, HCF_SUCCESS);
151     ASSERT_NE(sign, nullptr);
152 
153     HcfSignSpi signObj { .base = *(HcfObjectBase *)sign };
154 
155     ret = EngineSetSignSpecInt(&signObj, PSS_SALT_LEN_INT, RSA_PSS_SALTLEN_DIGEST);
156     ASSERT_NE(ret, HCF_SUCCESS);
157 
158     ret = EngineSetSignSpecInt(&signObj, PSS_SALT_LEN_INT, RSA_PSS_SALTLEN_MAX_SIGN);
159     ASSERT_NE(ret, HCF_SUCCESS);
160 
161     ret = EngineSetSignSpecInt(&signObj, PSS_SALT_LEN_INT, RSA_PSS_SALTLEN_MAX);
162     ASSERT_NE(ret, HCF_SUCCESS);
163 
164     sign->base.destroy((HcfObjectBase *)sign);
165 }
166 
167 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest008, TestSize.Level0)
168 {
169     HcfResult ret = EngineGetSignSpecInt(nullptr, PSS_SALT_LEN_INT, nullptr);
170     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
171 
172     ret = EngineGetSignSpecInt((HcfSignSpi *)&g_obj, PSS_SALT_LEN_INT, nullptr);
173     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
174 
175     int32_t returnInt = 0;
176     ret = EngineGetSignSpecInt((HcfSignSpi *)&g_obj, PSS_SALT_LEN_INT, &returnInt);
177     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
178 }
179 
180 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest009, TestSize.Level0)
181 {
182     HcfResult ret = EngineGetSignSpecString(nullptr, PSS_SALT_LEN_INT, nullptr);
183     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
184 
185     ret = EngineGetSignSpecString((HcfSignSpi *)&g_obj, PSS_SALT_LEN_INT, nullptr);
186     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
187 
188     char *returnString;
189     ret = EngineGetSignSpecString((HcfSignSpi *)&g_obj, PSS_SALT_LEN_INT, &returnString);
190     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
191 }
192 
193 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest010, TestSize.Level0)
194 {
195     HcfResult ret = EngineSetVerifySpecInt(nullptr, PSS_SALT_LEN_INT, 0);
196     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
197 
198     ret = EngineSetVerifySpecInt((HcfVerifySpi *)&g_obj, PSS_MD_NAME_STR, 0);
199     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
200 
201     HcfVerify *verify = nullptr;
202     HcfResult res = HcfVerifyCreate("DSA1024|SHA256", &verify);
203     ASSERT_EQ(res, HCF_SUCCESS);
204     ASSERT_NE(verify, nullptr);
205 
206     HcfVerifySpi verifyObj { .base = *(HcfObjectBase *)verify };
207 
208     ret = EngineSetVerifySpecInt(&verifyObj, PSS_SALT_LEN_INT, RSA_PSS_SALTLEN_DIGEST);
209     ASSERT_NE(ret, HCF_SUCCESS);
210 
211     ret = EngineSetVerifySpecInt(&verifyObj, PSS_SALT_LEN_INT, RSA_PSS_SALTLEN_AUTO);
212     ASSERT_NE(ret, HCF_SUCCESS);
213 
214     ret = EngineSetVerifySpecInt(&verifyObj, PSS_SALT_LEN_INT, RSA_PSS_SALTLEN_MAX);
215     ASSERT_NE(ret, HCF_SUCCESS);
216 
217     verify->base.destroy((HcfObjectBase *)verify);
218 }
219 
220 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest011, TestSize.Level0)
221 {
222     HcfResult ret = EngineGetVerifySpecInt(nullptr, PSS_SALT_LEN_INT, nullptr);
223     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
224 
225     ret =EngineGetVerifySpecInt((HcfVerifySpi *)&g_obj, PSS_SALT_LEN_INT, nullptr);
226     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
227 
228     int32_t returnInt = 0;
229     ret =EngineGetVerifySpecInt((HcfVerifySpi *)&g_obj, PSS_SALT_LEN_INT, &returnInt);
230     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
231 }
232 
233 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest012, TestSize.Level0)
234 {
235     HcfResult ret = EngineGetVerifySpecString(nullptr, PSS_SALT_LEN_INT, nullptr);
236     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
237 
238     ret = EngineGetVerifySpecString((HcfVerifySpi *)&g_obj, PSS_SALT_LEN_INT, nullptr);
239     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
240 
241     char *returnString = nullptr;
242     ret = EngineGetVerifySpecString((HcfVerifySpi *)&g_obj, PSS_SALT_LEN_INT, &returnString);
243     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
244 }
245 
246 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest013, TestSize.Level0)
247 {
248     HcfResult ret = HcfSignSpiRsaCreate(nullptr, nullptr);
249     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
250 
251     ret = HcfSignSpiRsaCreate((HcfSignatureParams *)&g_obj, nullptr);
252     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
253 
254     HcfSignSpi *returnObj = nullptr;
255     ret = HcfSignSpiRsaCreate((HcfSignatureParams *)&g_obj, &returnObj);
256     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
257 }
258 
259 HWTEST_F(CryptoSignatureExceptionTest, CryptoSignatureExceptionTest014, TestSize.Level0)
260 {
261     HcfResult ret = HcfVerifySpiRsaCreate(nullptr, nullptr);
262     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
263 
264     ret = HcfVerifySpiRsaCreate((HcfSignatureParams *)&g_obj, nullptr);
265     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
266 
267     HcfVerifySpi *returnObj = nullptr;
268     ret = HcfVerifySpiRsaCreate((HcfSignatureParams *)&g_obj, &returnObj);
269     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
270 }
271 }