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_key.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 static string g_testPubkeyX509Str512 = "-----BEGIN PUBLIC KEY-----\n"
27 "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKG0KN3tjZM8dCNfCg9bcmZM3Bhv/mRr\n"
28 "Mxuvua2Ru8Kr1NL+/wyeEMnIARFr+Alf1Tyfjy0PWwFnf8jHWRsz0vkCAwEAAQ==\n"
29 "-----END PUBLIC KEY-----\n";
30 
31 static string g_testPubkeyPkcs1Str512 = "-----BEGIN RSA PUBLIC KEY-----\n"
32 "MEgCQQChtCjd7Y2TPHQjXwoPW3JmTNwYb/5kazMbr7mtkbvCq9TS/v8MnhDJyAER\n"
33 "a/gJX9U8n48tD1sBZ3/Ix1kbM9L5AgMBAAE=\n"
34 "-----END RSA PUBLIC KEY-----\n";
35 
36 namespace {
37 class NativeAsymKeyTest : public testing::Test {
38 public:
39     static void SetUpTestCase();
40     static void TearDownTestCase();
41     void SetUp();
42     void TearDown();
43 };
44 
SetUpTestCase()45 void NativeAsymKeyTest::SetUpTestCase() {}
TearDownTestCase()46 void NativeAsymKeyTest::TearDownTestCase() {}
47 
SetUp()48 void NativeAsymKeyTest::SetUp() // add init here, this will be called before test.
49 {
50 }
51 
TearDown()52 void NativeAsymKeyTest::TearDown() // add destroy here, this will be called when test case done.
53 {
54 }
55 
56 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest001, TestSize.Level0)
57 {
58     OH_CryptoAsymKeyGenerator *generator = nullptr;
59     OH_CryptoKeyPair *keyCtx = nullptr;
60     OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("DSA2048", &generator);
61     EXPECT_EQ(ret, CRYPTO_SUCCESS);
62     ret = OH_CryptoAsymKeyGenerator_Generate(generator, &keyCtx);
63     EXPECT_EQ(ret, CRYPTO_SUCCESS);
64 
65     const char *algoName = OH_CryptoAsymKeyGenerator_GetAlgoName(generator);
66     ASSERT_NE(algoName, nullptr);
67 
68     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx);
69 
70     Crypto_DataBlob dataBlob = { .data = nullptr, .len = 0 };
71     ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_Q_DATABLOB, &dataBlob);
72     EXPECT_EQ(ret, CRYPTO_SUCCESS);
73     ASSERT_NE(dataBlob.data, nullptr);
74     ASSERT_NE(dataBlob.len, 0);
75     HcfFree(dataBlob.data);
76     OH_CryptoKeyPair_Destroy(keyCtx);
77     OH_CryptoAsymKeyGenerator_Destroy(generator);
78 }
79 
80 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest002, TestSize.Level0)
81 {
82     OH_CryptoAsymKeyGenerator *generator = nullptr;
83     OH_Crypto_ErrCode res = OH_CryptoAsymKeyGenerator_Create("RSA512", &generator);
84     EXPECT_EQ(res, CRYPTO_SUCCESS);
85     EXPECT_NE(generator, nullptr);
86 
87     OH_CryptoKeyPair *dupKeyPair = nullptr;
88     Crypto_DataBlob pubKeyX509Str = {};
89     pubKeyX509Str.data = reinterpret_cast<uint8_t*>(const_cast<char*>(g_testPubkeyX509Str512.c_str()));
90     pubKeyX509Str.len = strlen(g_testPubkeyX509Str512.c_str());
91 
92     Crypto_DataBlob pubKeyPkcs1Str = {};
93     pubKeyPkcs1Str.data = reinterpret_cast<uint8_t*>(const_cast<char*>(g_testPubkeyPkcs1Str512.c_str()));
94     pubKeyPkcs1Str.len = strlen(g_testPubkeyPkcs1Str512.c_str());
95     res = OH_CryptoAsymKeyGenerator_Convert(generator, CRYPTO_PEM, &pubKeyX509Str, nullptr, &dupKeyPair);
96     EXPECT_EQ(res, CRYPTO_SUCCESS);
97 
98     OH_CryptoPubKey *pubkey = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
99     Crypto_DataBlob retBlob = { .data = nullptr, .len = 0 };
100     res = OH_CryptoPubKey_Encode(pubkey, CRYPTO_PEM, "PKCS1", &retBlob);
101     EXPECT_EQ(res, CRYPTO_SUCCESS);
102     int32_t cmpRes = strcmp(reinterpret_cast<const char*>(retBlob.data),
103         reinterpret_cast<const char*>(pubKeyPkcs1Str.data));
104     EXPECT_EQ(cmpRes, CRYPTO_SUCCESS);
105 
106     Crypto_DataBlob retBlobX509 = { .data = nullptr, .len = 0 };
107     res = OH_CryptoPubKey_Encode(pubkey, CRYPTO_PEM, "X509", &retBlobX509);
108     EXPECT_EQ(res, CRYPTO_SUCCESS);
109     cmpRes = strcmp(reinterpret_cast<const char*>(retBlobX509.data), reinterpret_cast<const char*>(pubKeyX509Str.data));
110     EXPECT_EQ(cmpRes, CRYPTO_SUCCESS);
111 
112 
113     OH_Crypto_FreeDataBlob(&retBlob);
114     OH_Crypto_FreeDataBlob(&retBlobX509);
115     OH_CryptoKeyPair_Destroy(dupKeyPair);
116     OH_CryptoAsymKeyGenerator_Destroy(generator);
117 }
118 
119 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest003, TestSize.Level0)
120 {
121     OH_CryptoAsymKeyGenerator *generator = nullptr;
122     OH_CryptoKeyPair *keyCtx = nullptr;
123     OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("RSA768", &generator);
124     EXPECT_EQ(ret, CRYPTO_SUCCESS);
125     ret = OH_CryptoAsymKeyGenerator_Generate(generator, &keyCtx);
126     EXPECT_EQ(ret, CRYPTO_SUCCESS);
127 
128     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx);
129     Crypto_DataBlob dataBlobE = { .data = nullptr, .len = 0 };
130     ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_RSA_E_DATABLOB, &dataBlobE);
131     EXPECT_EQ(ret, CRYPTO_SUCCESS);
132     ASSERT_NE(dataBlobE.data, nullptr);
133     ASSERT_NE(dataBlobE.len, 0);
134     HcfFree(dataBlobE.data);
135     OH_CryptoKeyPair_Destroy(keyCtx);
136     OH_CryptoAsymKeyGenerator_Destroy(generator);
137 }
138 
139 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest004, TestSize.Level0)
140 {
141     OH_CryptoAsymKeyGenerator *ctx = nullptr;
142     OH_CryptoKeyPair *keyPair = nullptr;
143     OH_Crypto_ErrCode ret;
144 
145     ret = OH_CryptoAsymKeyGenerator_Create("RSA512|PRIMES_2", &ctx);
146     ASSERT_EQ(ret, CRYPTO_SUCCESS);
147 
148     ret = OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair);
149     ASSERT_EQ(ret, CRYPTO_SUCCESS);
150 
151     const char *algoName = OH_CryptoAsymKeyGenerator_GetAlgoName(ctx);
152     EXPECT_NE(algoName, nullptr);
153 
154     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
155     ASSERT_EQ(ret, CRYPTO_SUCCESS);
156 
157     Crypto_DataBlob retBlob = { .data = nullptr, .len = 0 };
158     ret = OH_CryptoPubKey_Encode(pubKey, CRYPTO_PEM, "PKCS1", &retBlob);
159     ASSERT_EQ(ret, CRYPTO_SUCCESS);
160 
161     OH_CryptoKeyPair *dupKeyPair = nullptr;
162     ret = OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_PEM, &retBlob, nullptr, &dupKeyPair);
163     ASSERT_EQ(ret, CRYPTO_SUCCESS);
164 
165     OH_CryptoPubKey *pubKey1 = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
166     ASSERT_EQ(ret, CRYPTO_SUCCESS);
167     Crypto_DataBlob dataBlob = { .data = nullptr, .len = 0 };
168 
169     ret = OH_CryptoPubKey_GetParam(pubKey1, CRYPTO_RSA_N_DATABLOB, &dataBlob);
170     ASSERT_EQ(ret, CRYPTO_SUCCESS);
171     ASSERT_NE(dataBlob.data, nullptr);
172     ASSERT_NE(dataBlob.len, 0);
173     OH_Crypto_FreeDataBlob(&dataBlob);
174 
175     OH_CryptoAsymKeyGenerator_Destroy(ctx);
176     OH_CryptoKeyPair_Destroy(keyPair);
177     OH_CryptoKeyPair_Destroy(dupKeyPair);
178 }
179 
180 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest005, TestSize.Level0)
181 {
182     OH_CryptoAsymKeyGenerator *ctx = nullptr;
183     OH_CryptoKeyPair *keyPair = nullptr;
184     OH_Crypto_ErrCode ret;
185 
186     ret = OH_CryptoAsymKeyGenerator_Create("Ed25519", &ctx);
187     ASSERT_EQ(ret, CRYPTO_SUCCESS);
188 
189     ret = OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair);
190     ASSERT_EQ(ret, CRYPTO_SUCCESS);
191 
192     const char *algoName = OH_CryptoAsymKeyGenerator_GetAlgoName(ctx);
193     EXPECT_NE(algoName, nullptr);
194 
195     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
196     ASSERT_EQ(ret, CRYPTO_SUCCESS);
197 
198     Crypto_DataBlob retBlob = { .data = nullptr, .len = 0 };
199     ret = OH_CryptoPubKey_Encode(pubKey, CRYPTO_DER, nullptr, &retBlob);
200     ASSERT_EQ(ret, CRYPTO_SUCCESS);
201 
202     OH_CryptoKeyPair *dupKeyPair = nullptr;
203     ret = OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &retBlob, nullptr, &dupKeyPair);
204     ASSERT_EQ(ret, CRYPTO_SUCCESS);
205 
206     OH_CryptoPubKey *pubKey1 = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
207     ASSERT_EQ(ret, CRYPTO_SUCCESS);
208     Crypto_DataBlob dataBlob = { .data = nullptr, .len = 0 };
209 
210     ret = OH_CryptoPubKey_GetParam(pubKey1, CRYPTO_ED25519_PK_DATABLOB, &dataBlob);
211     ASSERT_EQ(ret, CRYPTO_SUCCESS);
212     ASSERT_NE(dataBlob.data, nullptr);
213     ASSERT_NE(dataBlob.len, 0);
214     OH_Crypto_FreeDataBlob(&dataBlob);
215 
216     OH_CryptoAsymKeyGenerator_Destroy(ctx);
217     OH_CryptoKeyPair_Destroy(keyPair);
218     OH_CryptoKeyPair_Destroy(dupKeyPair);
219 }
220 }