1 /*
2 * Copyright (C) 2024 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 "crypto_common.h"
18 #include "crypto_asym_cipher.h"
19 #include "log.h"
20 #include "memory.h"
21 #include "memory_mock.h"
22
23 using namespace std;
24 using namespace testing::ext;
25
26 class NativeAsymCipherTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp();
31 void TearDown();
32 };
33
SetUpTestCase()34 void NativeAsymCipherTest::SetUpTestCase() {}
35
TearDownTestCase()36 void NativeAsymCipherTest::TearDownTestCase() {}
37
SetUp()38 void NativeAsymCipherTest::SetUp()
39 {
40 }
41
TearDown()42 void NativeAsymCipherTest::TearDown()
43 {
44 }
45
46 HWTEST_F(NativeAsymCipherTest, NativeAsymCipherTest001, TestSize.Level0)
47 {
48 OH_CryptoAsymKeyGenerator *keyGen = nullptr;
49 OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("RSA3072", &keyGen);
50 EXPECT_EQ(ret, CRYPTO_SUCCESS);
51 ASSERT_NE(keyGen, nullptr);
52
53 OH_CryptoKeyPair *keyPair = nullptr;
54 ret = OH_CryptoAsymKeyGenerator_Generate(keyGen, &keyPair);
55 EXPECT_EQ(ret, CRYPTO_SUCCESS);
56 ASSERT_NE(keyPair, nullptr);
57
58 OH_CryptoAsymCipher *cipher = nullptr;
59 ret = OH_CryptoAsymCipher_Create("RSA3072|PKCS1", &cipher);
60 EXPECT_EQ(ret, CRYPTO_SUCCESS);
61 ASSERT_NE(cipher, nullptr);
62
63 ret = OH_CryptoAsymCipher_Init(cipher, CRYPTO_ENCRYPT_MODE, keyPair);
64 EXPECT_EQ(ret, CRYPTO_SUCCESS);
65
66 const char *testData = "Hello, RSA!";
67 Crypto_DataBlob in = {
68 .data = (uint8_t *)testData,
69 .len = strlen(testData)
70 };
71
72 Crypto_DataBlob out = { 0 };
73 ret = OH_CryptoAsymCipher_Final(cipher, &in, &out);
74 EXPECT_EQ(ret, CRYPTO_SUCCESS);
75 ASSERT_NE(out.data, nullptr);
76 ASSERT_GT(out.len, 0);
77
78 OH_CryptoAsymCipher_Destroy(cipher);
79 cipher = nullptr;
80 ret = OH_CryptoAsymCipher_Create("RSA3072|PKCS1", &cipher);
81 EXPECT_EQ(ret, CRYPTO_SUCCESS);
82 ASSERT_NE(cipher, nullptr);
83
84 ret = OH_CryptoAsymCipher_Init(cipher, CRYPTO_DECRYPT_MODE, keyPair);
85 EXPECT_EQ(ret, CRYPTO_SUCCESS);
86
87 Crypto_DataBlob decrypted = { 0 };
88 ret = OH_CryptoAsymCipher_Final(cipher, &out, &decrypted);
89 EXPECT_EQ(ret, CRYPTO_SUCCESS);
90 ASSERT_NE(decrypted.data, nullptr);
91 ASSERT_EQ(decrypted.len, strlen(testData));
92 EXPECT_EQ(memcmp(decrypted.data, testData, decrypted.len), 0);
93
94 OH_Crypto_FreeDataBlob(&out);
95 OH_Crypto_FreeDataBlob(&decrypted);
96 OH_CryptoAsymCipher_Destroy(cipher);
97 OH_CryptoAsymKeyGenerator_Destroy(keyGen);
98 OH_CryptoKeyPair_Destroy(keyPair);
99 }
100
101 HWTEST_F(NativeAsymCipherTest, NativeAsymCipherTest002, TestSize.Level0)
102 {
103 OH_CryptoAsymKeyGenerator *keyGen = nullptr;
104 OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("SM2_256", nullptr);
105 EXPECT_NE(ret, CRYPTO_SUCCESS);
106 ret = OH_CryptoAsymKeyGenerator_Create(nullptr, &keyGen);
107 EXPECT_NE(ret, CRYPTO_SUCCESS);
108 ret = OH_CryptoAsymKeyGenerator_Create("SM2_256", &keyGen);
109 EXPECT_EQ(ret, CRYPTO_SUCCESS);
110 OH_CryptoAsymKeyGenerator_Destroy(keyGen);
111 }
112
113 HWTEST_F(NativeAsymCipherTest, NativeAsymCipherTest003, TestSize.Level0)
114 {
115 OH_CryptoAsymKeyGenerator *keyGen = nullptr;
116 OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("SM2_256", &keyGen);
117 EXPECT_EQ(ret, CRYPTO_SUCCESS);
118
119 OH_CryptoKeyPair *keyPair = nullptr;
120 ret = OH_CryptoAsymKeyGenerator_Generate(nullptr, &keyPair);
121 EXPECT_NE(ret, CRYPTO_SUCCESS);
122 ASSERT_EQ(keyPair, nullptr);
123
124 ret = OH_CryptoAsymKeyGenerator_Generate(keyGen, nullptr);
125 EXPECT_NE(ret, CRYPTO_SUCCESS);
126
127 ret = OH_CryptoAsymKeyGenerator_Generate(keyGen, &keyPair);
128 EXPECT_EQ(ret, CRYPTO_SUCCESS);
129 ASSERT_NE(keyPair, nullptr);
130
131 OH_CryptoAsymKeyGenerator_Destroy(keyGen);
132 OH_CryptoKeyPair_Destroy(keyPair);
133 }
134
135 HWTEST_F(NativeAsymCipherTest, NativeAsymCipherTest004, TestSize.Level0)
136 {
137 OH_CryptoAsymKeyGenerator *keyGen = nullptr;
138 OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("SM2_256", &keyGen);
139 EXPECT_EQ(ret, CRYPTO_SUCCESS);
140
141 OH_CryptoKeyPair *keyPair = nullptr;
142 ret = OH_CryptoAsymKeyGenerator_Generate(keyGen, &keyPair);
143 EXPECT_EQ(ret, CRYPTO_SUCCESS);
144
145 OH_CryptoAsymCipher *cipher = nullptr;
146 ret = OH_CryptoAsymCipher_Create(nullptr, &cipher);
147 ASSERT_NE(ret, CRYPTO_SUCCESS);
148 EXPECT_EQ(cipher, nullptr);
149
150 ret = OH_CryptoAsymCipher_Create("SM2|SM3", nullptr);
151 EXPECT_NE(ret, CRYPTO_SUCCESS);
152
153 ret = OH_CryptoAsymCipher_Create("SM2|SM3", &cipher);
154 EXPECT_EQ(ret, CRYPTO_SUCCESS);
155 ASSERT_NE(cipher, nullptr);
156
157 OH_CryptoAsymCipher_Destroy(cipher);
158 OH_CryptoAsymKeyGenerator_Destroy(keyGen);
159 OH_CryptoKeyPair_Destroy(keyPair);
160 }
161
162 HWTEST_F(NativeAsymCipherTest, NativeAsymCipherTest005, TestSize.Level0)
163 {
164 OH_CryptoAsymKeyGenerator *keyGen = nullptr;
165 OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("SM2_256", &keyGen);
166 EXPECT_EQ(ret, CRYPTO_SUCCESS);
167
168 OH_CryptoKeyPair *keyPair = nullptr;
169 ret = OH_CryptoAsymKeyGenerator_Generate(keyGen, &keyPair);
170 EXPECT_EQ(ret, CRYPTO_SUCCESS);
171
172 OH_CryptoAsymCipher *cipher = nullptr;
173 ret = OH_CryptoAsymCipher_Create("SM2|SM3", &cipher);
174 EXPECT_EQ(ret, CRYPTO_SUCCESS);
175 ASSERT_NE(cipher, nullptr);
176
177 ret = OH_CryptoAsymCipher_Init(nullptr, CRYPTO_ENCRYPT_MODE, keyPair);
178 EXPECT_NE(ret, CRYPTO_SUCCESS);
179
180 ret = OH_CryptoAsymCipher_Init(cipher, CRYPTO_ENCRYPT_MODE, nullptr);
181 EXPECT_NE(ret, CRYPTO_SUCCESS);
182
183 ret = OH_CryptoAsymCipher_Init(cipher, (Crypto_CipherMode)2, nullptr);
184 EXPECT_NE(ret, CRYPTO_SUCCESS);
185
186 ret = OH_CryptoAsymCipher_Init(cipher, CRYPTO_ENCRYPT_MODE, keyPair);
187 EXPECT_EQ(ret, CRYPTO_SUCCESS);
188
189 const char *testData = "Hello, SM2!";
190 Crypto_DataBlob in = {
191 .data = (uint8_t *)testData,
192 .len = strlen(testData)
193 };
194
195 Crypto_DataBlob out = { 0 };
196 ret = OH_CryptoAsymCipher_Final(nullptr, &in, &out);
197 EXPECT_NE(ret, CRYPTO_SUCCESS);
198
199 ret = OH_CryptoAsymCipher_Final(cipher, &in, nullptr);
200 EXPECT_NE(ret, CRYPTO_SUCCESS);
201
202 ret = OH_CryptoAsymCipher_Final(cipher, &in, &out);
203 EXPECT_EQ(ret, CRYPTO_SUCCESS);
204 ASSERT_NE(out.data, nullptr);
205 ASSERT_GT(out.len, 0);
206
207 OH_Crypto_FreeDataBlob(&out);
208 OH_CryptoAsymCipher_Destroy(cipher);
209 OH_CryptoAsymKeyGenerator_Destroy(keyGen);
210 OH_CryptoKeyPair_Destroy(keyPair);
211 }
212
213 HWTEST_F(NativeAsymCipherTest, NativeAsymCipherTest006, TestSize.Level0)
214 {
215 OH_CryptoAsymKeyGenerator *keyGen = nullptr;
216 OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("SM2_256", &keyGen);
217 EXPECT_EQ(ret, CRYPTO_SUCCESS);
218
219 OH_CryptoKeyPair *keyPair = nullptr;
220 ret = OH_CryptoAsymKeyGenerator_Generate(keyGen, &keyPair);
221 EXPECT_EQ(ret, CRYPTO_SUCCESS);
222
223 OH_CryptoAsymCipher *cipher = nullptr;
224 ret = OH_CryptoAsymCipher_Create("SM2|SM3", &cipher);
225 EXPECT_EQ(ret, CRYPTO_SUCCESS);
226 ASSERT_NE(cipher, nullptr);
227
228 ret = OH_CryptoAsymCipher_Init(cipher, CRYPTO_ENCRYPT_MODE, keyPair);
229 EXPECT_EQ(ret, CRYPTO_SUCCESS);
230
231 const char *testData = "Hello, SM2!";
232 Crypto_DataBlob in = {
233 .data = (uint8_t *)testData,
234 .len = strlen(testData)
235 };
236
237 Crypto_DataBlob out = { 0 };
238 ret = OH_CryptoAsymCipher_Final(cipher, &in, &out);
239 EXPECT_EQ(ret, CRYPTO_SUCCESS);
240 ASSERT_NE(out.data, nullptr);
241 ASSERT_GT(out.len, 0);
242
243 OH_Crypto_FreeDataBlob(&out);
244 OH_CryptoAsymCipher_Destroy(cipher);
245 OH_CryptoAsymKeyGenerator_Destroy(keyGen);
246 OH_CryptoKeyPair_Destroy(keyPair);
247 }
248
249 HWTEST_F(NativeAsymCipherTest, NativeAsymCipherTest007, TestSize.Level0)
250 {
251 uint8_t testData[] = {
252 48, 118, 2, 32, 45, 153, 88, 82, 104, 221, 226, 43, 174, 21, 122, 248, 5, 232, 105, 41, 92, 95, 102, 224, 216,
253 149, 85, 236, 110, 6, 64, 188, 149, 70, 70, 183, 2, 32, 107, 93, 198, 247, 119, 18, 40, 110, 90, 156, 193, 158,
254 205, 113, 170, 128, 146, 109, 75, 17, 181, 109, 110, 91, 149, 5, 110, 233, 209, 78, 229, 96, 4, 32, 87, 167,
255 167, 247, 88, 146, 203, 234, 83, 126, 117, 129, 52, 142, 82, 54, 152, 226, 201, 111, 143, 115, 169, 125, 128,
256 42, 157, 31, 114, 198, 109, 244, 4, 14, 100, 227, 78, 195, 249, 179, 43, 70, 242, 69, 169, 10, 65, 123
257 };
258 Crypto_DataBlob out = {
259 .data = testData,
260 .len = sizeof(testData)
261 };
262
263 OH_CryptoSm2CiphertextSpec *sm2CipherSpec = nullptr;
264 OH_Crypto_ErrCode ret = OH_CryptoSm2CiphertextSpec_Create(&out, nullptr);
265 EXPECT_NE(ret, CRYPTO_SUCCESS);
266 ret = OH_CryptoSm2CiphertextSpec_Create(&out, &sm2CipherSpec);
267 EXPECT_EQ(ret, CRYPTO_SUCCESS);
268 ASSERT_NE(sm2CipherSpec, nullptr);
269
270 Crypto_DataBlob c1x = { 0 };
271 Crypto_DataBlob c1y = { 0 };
272 Crypto_DataBlob c2 = { 0 };
273 Crypto_DataBlob c3 = { 0 };
274 ret = OH_CryptoSm2CiphertextSpec_GetItem(nullptr, CRYPTO_SM2_CIPHERTEXT_C1_X, &c1x);
275 EXPECT_NE(ret, CRYPTO_SUCCESS);
276 ret = OH_CryptoSm2CiphertextSpec_GetItem(sm2CipherSpec, (CryptoSm2CiphertextSpec_item)4, &c1x);
277 EXPECT_NE(ret, CRYPTO_SUCCESS);
278 ret = OH_CryptoSm2CiphertextSpec_GetItem(sm2CipherSpec, CRYPTO_SM2_CIPHERTEXT_C1_X, nullptr);
279 EXPECT_NE(ret, CRYPTO_SUCCESS);
280
281 ret = OH_CryptoSm2CiphertextSpec_GetItem(sm2CipherSpec, CRYPTO_SM2_CIPHERTEXT_C1_X, &c1x);
282 EXPECT_EQ(ret, CRYPTO_SUCCESS);
283 ret = OH_CryptoSm2CiphertextSpec_GetItem(sm2CipherSpec, CRYPTO_SM2_CIPHERTEXT_C1_Y, &c1y);
284 EXPECT_EQ(ret, CRYPTO_SUCCESS);
285 ret = OH_CryptoSm2CiphertextSpec_GetItem(sm2CipherSpec, CRYPTO_SM2_CIPHERTEXT_C2, &c2);
286 EXPECT_EQ(ret, CRYPTO_SUCCESS);
287 ret = OH_CryptoSm2CiphertextSpec_GetItem(sm2CipherSpec, CRYPTO_SM2_CIPHERTEXT_C3, &c3);
288 EXPECT_EQ(ret, CRYPTO_SUCCESS);
289
290 OH_Crypto_FreeDataBlob(&c1x);
291 OH_Crypto_FreeDataBlob(&c1y);
292 OH_Crypto_FreeDataBlob(&c2);
293 OH_Crypto_FreeDataBlob(&c3);
294 OH_CryptoSm2CiphertextSpec_Destroy(sm2CipherSpec);
295 }
296
InitCryptoDataBlobs(Crypto_DataBlob * c1x,Crypto_DataBlob * c1y,Crypto_DataBlob * c2,Crypto_DataBlob * c3)297 static void InitCryptoDataBlobs(Crypto_DataBlob *c1x, Crypto_DataBlob *c1y, Crypto_DataBlob *c2, Crypto_DataBlob *c3)
298 {
299 static uint8_t c1xData[] = {45, 153, 88, 82, 104, 221, 226, 43, 174, 21, 122, 248, 5, 232, 105, 41, 92, 95, 102,
300 224, 216, 149, 85, 236, 110, 6, 64, 188, 149, 70, 70, 183};
301 static uint8_t c1yData[] = {107, 93, 198, 247, 119, 18, 40, 110, 90, 156, 193, 158, 205, 113, 170, 128, 146, 109,
302 75, 17, 181, 109, 110, 91, 149, 5, 110, 233, 209, 78, 229, 96};
303 static uint8_t c2Data[] = {100, 227, 78, 195, 249, 179, 43, 70, 242, 69, 169, 10, 65, 123};
304 static uint8_t c3Data[] = {87, 167, 167, 247, 88, 146, 203, 234, 83, 126, 117, 129, 52, 142, 82, 54, 152, 226, 201,
305 111, 143, 115, 169, 125, 128, 42, 157, 31, 114, 198, 109, 244};
306
307 c1x->data = c1xData;
308 c1x->len = sizeof(c1xData);
309
310 c1y->data = c1yData;
311 c1y->len = sizeof(c1yData);
312
313 c2->data = c2Data;
314 c2->len = sizeof(c2Data);
315
316 c3->data = c3Data;
317 c3->len = sizeof(c3Data);
318 }
319
320 HWTEST_F(NativeAsymCipherTest, NativeAsymCipherTest008, TestSize.Level0)
321 {
322 Crypto_DataBlob c1x = { 0 };
323 Crypto_DataBlob c1y = { 0 };
324 Crypto_DataBlob c2 = { 0 };
325 Crypto_DataBlob c3 = { 0 };
326 InitCryptoDataBlobs(&c1x, &c1y, &c2, &c3);
327
328 OH_CryptoSm2CiphertextSpec *sm2CipherSpec = nullptr;
329 OH_Crypto_ErrCode ret = OH_CryptoSm2CiphertextSpec_Create(nullptr, &sm2CipherSpec);
330 EXPECT_EQ(ret, CRYPTO_SUCCESS);
331 ASSERT_NE(sm2CipherSpec, nullptr);
332
333 ret = OH_CryptoSm2CiphertextSpec_SetItem(nullptr, CRYPTO_SM2_CIPHERTEXT_C1_X, &c1x);
334 EXPECT_NE(ret, CRYPTO_SUCCESS);
335 ret = OH_CryptoSm2CiphertextSpec_SetItem(sm2CipherSpec, (CryptoSm2CiphertextSpec_item)4, &c1x);
336 EXPECT_NE(ret, CRYPTO_SUCCESS);
337 ret = OH_CryptoSm2CiphertextSpec_SetItem(sm2CipherSpec, CRYPTO_SM2_CIPHERTEXT_C1_X, nullptr);
338 EXPECT_NE(ret, CRYPTO_SUCCESS);
339
340 ret = OH_CryptoSm2CiphertextSpec_SetItem(sm2CipherSpec, CRYPTO_SM2_CIPHERTEXT_C1_X, &c1x);
341 EXPECT_EQ(ret, CRYPTO_SUCCESS);
342 ret = OH_CryptoSm2CiphertextSpec_SetItem(sm2CipherSpec, CRYPTO_SM2_CIPHERTEXT_C1_Y, &c1y);
343 EXPECT_EQ(ret, CRYPTO_SUCCESS);
344 ret = OH_CryptoSm2CiphertextSpec_SetItem(sm2CipherSpec, CRYPTO_SM2_CIPHERTEXT_C2, &c2);
345 EXPECT_EQ(ret, CRYPTO_SUCCESS);
346 ret = OH_CryptoSm2CiphertextSpec_SetItem(sm2CipherSpec, CRYPTO_SM2_CIPHERTEXT_C3, &c3);
347 EXPECT_EQ(ret, CRYPTO_SUCCESS);
348
349 Crypto_DataBlob encoded = { 0 };
350 ret = OH_CryptoSm2CiphertextSpec_Encode(nullptr, &encoded);
351 EXPECT_NE(ret, CRYPTO_SUCCESS);
352 ret = OH_CryptoSm2CiphertextSpec_Encode(sm2CipherSpec, nullptr);
353 EXPECT_NE(ret, CRYPTO_SUCCESS);
354
355 ret = OH_CryptoSm2CiphertextSpec_Encode(sm2CipherSpec, &encoded);
356 EXPECT_EQ(ret, CRYPTO_SUCCESS);
357 ASSERT_NE(encoded.data, nullptr);
358 ASSERT_GT(encoded.len, 0);
359
360 OH_Crypto_FreeDataBlob(&encoded);
361 OH_CryptoSm2CiphertextSpec_Destroy(sm2CipherSpec);
362 }