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 <cinttypes>
17 #include <unistd.h>
18 #include <gtest/gtest.h>
19 #include "device_auth_defines.h"
20 #include "device_auth.h"
21 #include "string_util.h"
22 #include "cert_operation.h"
23 #include "identity_manager.h"
24 #include "identity_common.h"
25 
26 using namespace std;
27 using namespace testing::ext;
28 
29 namespace {
30 static const std::string TEST_GROUP_ID = "TestGroupId";
31 static const std::string TEST_DEVICE_ID = "TestDeviceId";
32 static const std::string TEST_REQUEST_JSON_STR = "TestRequestJsonStr";
33 static const std::string TEST_PIN_CODE = "11111";
34 static const int TEST_SIGNATURE_LEN = 32;
35 static const int TEST_OS_ACCOUNT_ID = 100;
36 
37 extern "C" int32_t GenerateCertInfo(const Uint8Buff *pkInfoStr, const Uint8Buff *pkInfoSignature, CertInfo *certInfo);
38 
39 class IdentityManagerTest : public testing::Test {
40 public:
41     static void SetUpTestCase();
42     static void TearDownTestCase();
43     void SetUp();
44     void TearDown();
45 };
46 
SetUpTestCase()47 void IdentityManagerTest::SetUpTestCase() {}
TearDownTestCase()48 void IdentityManagerTest::TearDownTestCase() {}
49 
SetUp()50 void IdentityManagerTest::SetUp()
51 {
52     int32_t ret = InitDeviceAuthService();
53     ASSERT_EQ(ret, HC_SUCCESS);
54 }
55 
TearDown()56 void IdentityManagerTest::TearDown()
57 {
58     DestroyDeviceAuthService();
59 }
60 
61 HWTEST_F(IdentityManagerTest, IdentityManagerTest001, TestSize.Level0)
62 {
63     int32_t ret = AddCertInfoToJson(nullptr, nullptr);
64     EXPECT_NE(ret, HC_SUCCESS);
65     CertInfo info = { { nullptr, 0 }, { nullptr, 0 }, P256 };
66     ret = AddCertInfoToJson(&info, nullptr);
67     EXPECT_NE(ret, HC_SUCCESS);
68     CJson *pkInfoJson = CreateJson();
69     ASSERT_NE(pkInfoJson, nullptr);
70     char *pkInfoStr = PackJsonToString(pkInfoJson);
71     FreeJson(pkInfoJson);
72     ASSERT_NE(pkInfoStr, nullptr);
73     info.pkInfoStr.val = (uint8_t *)pkInfoStr;
74     info.pkInfoStr.length = strlen(pkInfoStr) + 1;
75     info.signAlg = P256;
76     CJson *out = CreateJson();
77     ASSERT_NE(out, nullptr);
78     ret = AddCertInfoToJson(&info, out);
79     EXPECT_NE(ret, HC_SUCCESS);
80     uint8_t testSignature[TEST_SIGNATURE_LEN] = { 0 };
81     info.pkInfoSignature.val = testSignature;
82     info.pkInfoSignature.length = TEST_SIGNATURE_LEN;
83     ret = AddCertInfoToJson(&info, out);
84     EXPECT_EQ(ret, HC_SUCCESS);
85     FreeJsonString(pkInfoStr);
86     FreeJson(out);
87 }
88 
89 HWTEST_F(IdentityManagerTest, IdentityManagerTest002, TestSize.Level0)
90 {
91     Uint8Buff pkInfoBuf = { nullptr, 0 };
92     CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
93     int32_t ret = GenerateCertInfo(&pkInfoBuf, nullptr, &certInfo);
94     EXPECT_NE(ret, HC_SUCCESS);
95     CJson *pkInfoJson = CreateJson();
96     ASSERT_NE(pkInfoJson, nullptr);
97     char *pkInfoStr = PackJsonToString(pkInfoJson);
98     FreeJson(pkInfoJson);
99     pkInfoBuf.val = (uint8_t *)pkInfoStr;
100     pkInfoBuf.length = HcStrlen(pkInfoStr) + 1;
101     Uint8Buff pkInfoSigBuf = { nullptr, 0 };
102     ret = GenerateCertInfo(&pkInfoBuf, &pkInfoSigBuf, &certInfo);
103     EXPECT_NE(ret, HC_SUCCESS);
104     FreeJsonString(pkInfoStr);
105     HcFree(certInfo.pkInfoStr.val);
106 }
107 
108 HWTEST_F(IdentityManagerTest, IdentityManagerTest003, TestSize.Level0)
109 {
110     IdentityInfo *info = CreateIdentityInfo();
111     ASSERT_NE(info, nullptr);
112     int32_t ret = GetAccountRelatedCredInfo(TEST_OS_ACCOUNT_ID, TEST_GROUP_ID.c_str(),
113         TEST_DEVICE_ID.c_str(), true, info);
114     EXPECT_NE(ret, HC_SUCCESS);
115     ret = GetAccountRelatedCredInfo(TEST_OS_ACCOUNT_ID, nullptr, TEST_DEVICE_ID.c_str(), true, info);
116     EXPECT_NE(ret, HC_SUCCESS);
117     ret = GetAccountRelatedCredInfo(TEST_OS_ACCOUNT_ID, TEST_GROUP_ID.c_str(), nullptr, true, info);
118     DestroyIdentityInfo(info);
119     EXPECT_NE(ret, HC_SUCCESS);
120     ret = GetAccountRelatedCredInfo(TEST_OS_ACCOUNT_ID, TEST_GROUP_ID.c_str(), TEST_DEVICE_ID.c_str(), true, nullptr);
121     EXPECT_NE(ret, HC_SUCCESS);
122     ret = GetAccountAsymSharedSecret(TEST_OS_ACCOUNT_ID, nullptr, nullptr, nullptr);
123     EXPECT_NE(ret, HC_SUCCESS);
124     CertInfo peerCertInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
125     ret = GetAccountAsymSharedSecret(TEST_OS_ACCOUNT_ID, nullptr, &peerCertInfo, nullptr);
126     EXPECT_NE(ret, HC_SUCCESS);
127     ret = GetAccountSymSharedSecret(nullptr, nullptr, nullptr);
128     EXPECT_NE(ret, HC_SUCCESS);
129     CJson *in = CreateJson();
130     ASSERT_NE(in, nullptr);
131     ret = GetAccountSymSharedSecret(in, nullptr, nullptr);
132     EXPECT_NE(ret, HC_SUCCESS);
133     CJson *urlJson = CreateJson();
134     ASSERT_NE(urlJson, nullptr);
135     ret = GetAccountSymSharedSecret(in, urlJson, nullptr);
136     EXPECT_NE(ret, HC_SUCCESS);
137     FreeJson(in);
138     FreeJson(urlJson);
139     ret = GetAccountAsymCredInfo(TEST_OS_ACCOUNT_ID, nullptr, nullptr);
140     EXPECT_NE(ret, HC_SUCCESS);
141     CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
142     ret = GetAccountAsymCredInfo(TEST_OS_ACCOUNT_ID, &certInfo, nullptr);
143     EXPECT_NE(ret, HC_SUCCESS);
144     ret = GetAccountSymCredInfoByPeerUrl(nullptr, nullptr, nullptr);
145     EXPECT_NE(ret, HC_SUCCESS);
146     in = CreateJson();
147     ASSERT_NE(in, nullptr);
148     ret = GetAccountSymCredInfoByPeerUrl(in, nullptr, nullptr);
149     EXPECT_NE(ret, HC_SUCCESS);
150     urlJson = CreateJson();
151     ASSERT_NE(urlJson, nullptr);
152     ret = GetAccountSymCredInfoByPeerUrl(in, urlJson, nullptr);
153     EXPECT_NE(ret, HC_SUCCESS);
154     FreeJson(in);
155     FreeJson(urlJson);
156 }
157 
158 HWTEST_F(IdentityManagerTest, IdentityManagerTest004, TestSize.Level0)
159 {
160     const CredentialOperator *credOperator = GetCredentialOperator();
161     EXPECT_NE(credOperator, nullptr);
162     int32_t ret = credOperator->queryCredential(TEST_REQUEST_JSON_STR.c_str(), nullptr);
163     EXPECT_NE(ret, HC_SUCCESS);
164 }
165 
166 HWTEST_F(IdentityManagerTest, IdentityManagerTest005, TestSize.Level0)
167 {
168     Uint8Buff srcPsk = { nullptr, 0 };
169     Uint8Buff sharedSecret = { nullptr, 0 };
170     int32_t ret = ConvertPsk(&srcPsk, &sharedSecret);
171     EXPECT_NE(ret, HC_SUCCESS);
172 }
173 
174 HWTEST_F(IdentityManagerTest, IdentityManagerTest006, TestSize.Level0)
175 {
176     const AuthIdentity *identity = GetGroupAuthIdentity();
177     EXPECT_NE(identity, nullptr);
178     int32_t ret = identity->getCredInfoByPeerUrl(nullptr, nullptr, nullptr);
179     EXPECT_NE(ret, HC_SUCCESS);
180     CJson *in = CreateJson();
181     ASSERT_NE(in, nullptr);
182     ret = identity->getCredInfoByPeerUrl(in, nullptr, nullptr);
183     EXPECT_NE(ret, HC_SUCCESS);
184     Uint8Buff presharedUrl = { nullptr, 0 };
185     ret = identity->getCredInfoByPeerUrl(in, &presharedUrl, nullptr);
186     EXPECT_NE(ret, HC_SUCCESS);
187     ret = identity->getSharedSecretByUrl(nullptr, nullptr, ALG_EC_SPEKE, nullptr);
188     EXPECT_NE(ret, HC_SUCCESS);
189     ret = identity->getSharedSecretByUrl(in, nullptr, ALG_EC_SPEKE, nullptr);
190     EXPECT_NE(ret, HC_SUCCESS);
191     ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_EC_SPEKE, nullptr);
192     EXPECT_NE(ret, HC_SUCCESS);
193     ret = identity->getCredInfoByPeerCert(nullptr, nullptr, nullptr);
194     EXPECT_NE(ret, HC_SUCCESS);
195     ret = identity->getCredInfoByPeerCert(in, nullptr, nullptr);
196     EXPECT_NE(ret, HC_SUCCESS);
197     CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
198     ret = identity->getCredInfoByPeerCert(in, &certInfo, nullptr);
199     EXPECT_NE(ret, HC_SUCCESS);
200     ret = identity->getSharedSecretByPeerCert(nullptr, nullptr, ALG_EC_SPEKE, nullptr);
201     EXPECT_NE(ret, HC_SUCCESS);
202     ret = identity->getSharedSecretByPeerCert(in, nullptr, ALG_EC_SPEKE, nullptr);
203     EXPECT_NE(ret, HC_SUCCESS);
204     CertInfo peerCertInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
205     ret = identity->getSharedSecretByPeerCert(in, &peerCertInfo, ALG_EC_SPEKE, nullptr);
206     EXPECT_NE(ret, HC_SUCCESS);
207     FreeJson(in);
208 }
209 
210 HWTEST_F(IdentityManagerTest, IdentityManagerTest007, TestSize.Level0)
211 {
212     const AuthIdentity *identity = GetP2pAuthIdentity();
213     EXPECT_NE(identity, nullptr);
214     CJson *in = CreateJson();
215     ASSERT_NE(in, nullptr);
216     int32_t ret = identity->getCredInfosByPeerIdentity(in, nullptr);
217     EXPECT_NE(ret, HC_SUCCESS);
218     (void)AddIntToJson(in, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
219     (void)AddStringToJson(in, FIELD_PEER_CONN_DEVICE_ID, TEST_DEVICE_ID.c_str());
220     ret = identity->getCredInfosByPeerIdentity(in, nullptr);
221     EXPECT_NE(ret, HC_SUCCESS);
222     (void)AddIntToJson(in, FIELD_ACQURIED_TYPE, ACQUIRE_TYPE_INVALID);
223     ret = identity->getCredInfosByPeerIdentity(in, nullptr);
224     EXPECT_NE(ret, HC_SUCCESS);
225     FreeJson(in);
226     ret = identity->getCredInfoByPeerUrl(nullptr, nullptr, nullptr);
227     EXPECT_NE(ret, HC_SUCCESS);
228     in = CreateJson();
229     ASSERT_NE(in, nullptr);
230     ret = identity->getCredInfoByPeerUrl(in, nullptr, nullptr);
231     EXPECT_NE(ret, HC_SUCCESS);
232     Uint8Buff presharedUrl = { nullptr, 0 };
233     ret = identity->getCredInfoByPeerUrl(in, &presharedUrl, nullptr);
234     EXPECT_NE(ret, HC_SUCCESS);
235     IdentityInfo *info = nullptr;
236     ret = identity->getCredInfoByPeerUrl(in, &presharedUrl, &info);
237     EXPECT_NE(ret, HC_SUCCESS);
238     (void)AddIntToJson(in, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
239     Uint8Buff sharedSecret = { nullptr, 0 };
240     ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
241     EXPECT_NE(ret, HC_SUCCESS);
242     ret = identity->getSharedSecretByUrl(nullptr, nullptr, ALG_EC_SPEKE, nullptr);
243     EXPECT_NE(ret, HC_SUCCESS);
244     ret = identity->getSharedSecretByUrl(in, nullptr, ALG_EC_SPEKE, nullptr);
245     EXPECT_NE(ret, HC_SUCCESS);
246     ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_EC_SPEKE, nullptr);
247     EXPECT_NE(ret, HC_SUCCESS);
248     FreeJson(in);
249 }
250 
251 HWTEST_F(IdentityManagerTest, IdentityManagerTest008, TestSize.Level0)
252 {
253     const AuthIdentity *identity = GetPinAuthIdentity();
254     EXPECT_NE(identity, nullptr);
255     int32_t ret = identity->getCredInfoByPeerUrl(nullptr, nullptr, nullptr);
256     EXPECT_NE(ret, HC_SUCCESS);
257     CJson *in = CreateJson();
258     ASSERT_NE(in, nullptr);
259     ret = identity->getCredInfoByPeerUrl(in, nullptr, nullptr);
260     EXPECT_NE(ret, HC_SUCCESS);
261     Uint8Buff presharedUrl = { nullptr, 0 };
262     ret = identity->getCredInfoByPeerUrl(in, &presharedUrl, nullptr);
263     EXPECT_NE(ret, HC_SUCCESS);
264     IdentityInfo *info = nullptr;
265     CJson *urlJson = CreateJson();
266     ASSERT_NE(urlJson, nullptr);
267     char *urlStr = PackJsonToString(urlJson);
268     FreeJson(urlJson);
269     ASSERT_NE(urlStr, nullptr);
270     presharedUrl.val = (uint8_t *)urlStr;
271     presharedUrl.length = HcStrlen(urlStr) + 1;
272     ret = identity->getCredInfoByPeerUrl(in, &presharedUrl, &info);
273     EXPECT_NE(ret, HC_SUCCESS);
274     ret = identity->getSharedSecretByUrl(nullptr, nullptr, ALG_EC_SPEKE, nullptr);
275     EXPECT_NE(ret, HC_SUCCESS);
276     ret = identity->getSharedSecretByUrl(in, nullptr, ALG_EC_SPEKE, nullptr);
277     EXPECT_NE(ret, HC_SUCCESS);
278     ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_EC_SPEKE, nullptr);
279     EXPECT_NE(ret, HC_SUCCESS);
280     (void)AddStringToJson(in, FIELD_PIN_CODE, TEST_PIN_CODE.c_str());
281     ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_ISO, nullptr);
282     EXPECT_NE(ret, HC_SUCCESS);
283     ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_EC_SPEKE, nullptr);
284     EXPECT_NE(ret, HC_SUCCESS);
285     FreeJson(in);
286     FreeJsonString(urlStr);
287 }
288 }