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 }