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 "hc_dev_info_mock.h"
21 #include "pseudonym_manager.h"
22
23 using namespace std;
24 using namespace testing::ext;
25
26 namespace {
27 #define TEST_PSEUDONYM_ID "1234ABCD"
28 #define TEST_PSEUDONYM_ID2 "4567ABCD"
29 #define TEST_DEVICE_ID "TestAuthId"
30 #define TEST_DEVICE_ID2 "TestAuthId2"
31 #define TEST_REAL_INFO "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b"
32 #define TEST_REAL_INFO2 "87364761534f454d33567a73424e794f33573330507069434b31676f72547068"
33 #define TEST_INDEX_KEY "DCBA4321"
34 #define TEST_INDEX_KEY2 "DCBA6789"
35
36 static const std::string TEST_GROUP_DATA_PATH = "/data/service/el1/public/deviceauthMock";
37 static const int TEST_DEV_AUTH_BUFFER_SIZE = 128;
38
39 class PrivacyEnhancementTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase()47 void PrivacyEnhancementTest::SetUpTestCase() {}
TearDownTestCase()48 void PrivacyEnhancementTest::TearDownTestCase() {}
49
RemoveDir(const char * path)50 static void RemoveDir(const char *path)
51 {
52 char strBuf[TEST_DEV_AUTH_BUFFER_SIZE] = { 0 };
53 if (path == nullptr) {
54 return;
55 }
56 if (sprintf_s(strBuf, sizeof(strBuf) - 1, "rm -rf %s", path) < 0) {
57 return;
58 }
59 system(strBuf);
60 }
61
DeleteDatabase()62 static void DeleteDatabase()
63 {
64 RemoveDir(TEST_GROUP_DATA_PATH.c_str());
65 }
66
SetUp()67 void PrivacyEnhancementTest::SetUp()
68 {
69 DeleteDatabase();
70 PseudonymManager *manager = GetPseudonymInstance();
71 ASSERT_NE(manager, nullptr);
72 manager->loadPseudonymData();
73 }
74
TearDown()75 void PrivacyEnhancementTest::TearDown()
76 {
77 DestroyPseudonymManager();
78 }
79
80 HWTEST_F(PrivacyEnhancementTest, GetRealInfoTest001, TestSize.Level0)
81 {
82 PseudonymManager *manager = GetPseudonymInstance();
83 ASSERT_NE(manager, nullptr);
84 char *pdid1 = nullptr;
85 char *peerInfo1 = nullptr;
86 int32_t ret = manager->getRealInfo(DEFAULT_OS_ACCOUNT, pdid1, &peerInfo1);
87 EXPECT_NE(ret, HC_SUCCESS);
88
89 char *peerInfo2 = nullptr;
90 ret = manager->getRealInfo(DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, &peerInfo2);
91 EXPECT_EQ(ret, HC_SUCCESS);
92 }
93
94 HWTEST_F(PrivacyEnhancementTest, GetRealInfoTest002, TestSize.Level0)
95 {
96 PseudonymManager *manager = GetPseudonymInstance();
97 ASSERT_NE(manager, nullptr);
98
99 int32_t ret = manager->savePseudonymId(
100 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, TEST_REAL_INFO, TEST_DEVICE_ID, TEST_INDEX_KEY);
101 EXPECT_EQ(ret, HC_SUCCESS);
102
103 char *realInfo1 = nullptr;
104 ret = manager->getRealInfo(DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, &realInfo1);
105 EXPECT_EQ(ret, HC_SUCCESS);
106 EXPECT_EQ(*realInfo1, *(TEST_REAL_INFO));
107 HcFree(realInfo1);
108
109 char *realInfo2 = nullptr;
110 ret = manager->getRealInfo(DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID2, &realInfo2);
111 EXPECT_EQ(ret, HC_SUCCESS);
112 HcFree(realInfo2);
113
114 ret = manager->deletePseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY);
115 EXPECT_EQ(ret, HC_SUCCESS);
116 }
117
118 HWTEST_F(PrivacyEnhancementTest, GetPseudonymIdTest001, TestSize.Level0)
119 {
120 PseudonymManager *manager = GetPseudonymInstance();
121 ASSERT_NE(manager, nullptr);
122
123 int32_t ret = manager->savePseudonymId(
124 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, TEST_REAL_INFO, TEST_DEVICE_ID, TEST_INDEX_KEY);
125 EXPECT_EQ(ret, HC_SUCCESS);
126
127 char *indexKey1 = nullptr;
128 char *pseudonymId1 = nullptr;
129 ret = manager->getPseudonymId(DEFAULT_OS_ACCOUNT, indexKey1, &pseudonymId1);
130 EXPECT_NE(ret, HC_SUCCESS);
131
132 char *pseudonymId2 = nullptr;
133 ret = manager->getPseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY, &pseudonymId2);
134 EXPECT_EQ(ret, HC_SUCCESS);
135 HcFree(pseudonymId2);
136
137 char *pseudonymId3 = nullptr;
138 ret = manager->getPseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY2, &pseudonymId3);
139 EXPECT_EQ(ret, HC_SUCCESS);
140 HcFree(pseudonymId3);
141
142 ret = manager->deletePseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY);
143 EXPECT_EQ(ret, HC_SUCCESS);
144 }
145
146 HWTEST_F(PrivacyEnhancementTest, GetPseudonymIdTest002, TestSize.Level0)
147 {
148 PseudonymManager *manager = GetPseudonymInstance();
149 ASSERT_NE(manager, nullptr);
150
151 char *indexKey1 = nullptr;
152 char *pseudonymId1 = nullptr;
153 int32_t ret = manager->getPseudonymId(DEFAULT_OS_ACCOUNT, indexKey1, &pseudonymId1);
154 EXPECT_NE(ret, HC_SUCCESS);
155
156 ret = manager->savePseudonymId(
157 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, TEST_REAL_INFO, TEST_DEVICE_ID, TEST_INDEX_KEY);
158 EXPECT_EQ(ret, HC_SUCCESS);
159
160 char *pseudonymId2 = nullptr;
161 ret = manager->getPseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY, &pseudonymId2);
162 EXPECT_EQ(*pseudonymId2, *(TEST_PSEUDONYM_ID));
163 EXPECT_EQ(ret, HC_SUCCESS);
164 HcFree(pseudonymId2);
165
166 ret = manager->deletePseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY);
167 EXPECT_EQ(ret, HC_SUCCESS);
168 }
169
170 HWTEST_F(PrivacyEnhancementTest, SavePseudonymIdTest001, TestSize.Level0)
171 {
172 PseudonymManager *manager = GetPseudonymInstance();
173 ASSERT_NE(manager, nullptr);
174
175 int32_t ret = manager->savePseudonymId(
176 DEFAULT_OS_ACCOUNT, nullptr, TEST_REAL_INFO, TEST_DEVICE_ID, TEST_INDEX_KEY);
177 EXPECT_NE(ret, HC_SUCCESS);
178
179 ret = manager->savePseudonymId(DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, nullptr, TEST_DEVICE_ID, TEST_INDEX_KEY);
180 EXPECT_NE(ret, HC_SUCCESS);
181
182 ret = manager->savePseudonymId(DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, TEST_REAL_INFO, nullptr, TEST_INDEX_KEY);
183 EXPECT_NE(ret, HC_SUCCESS);
184
185 ret = manager->savePseudonymId(DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, TEST_REAL_INFO, TEST_DEVICE_ID, nullptr);
186 EXPECT_NE(ret, HC_SUCCESS);
187 }
188
189 HWTEST_F(PrivacyEnhancementTest, SavePseudonymIdTest002, TestSize.Level0)
190 {
191 PseudonymManager *manager = GetPseudonymInstance();
192 ASSERT_NE(manager, nullptr);
193
194 int32_t ret = manager->savePseudonymId(
195 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, TEST_REAL_INFO, TEST_DEVICE_ID, TEST_INDEX_KEY);
196 EXPECT_EQ(ret, HC_SUCCESS);
197
198 ret = manager->savePseudonymId(
199 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID2, TEST_REAL_INFO2, TEST_DEVICE_ID2, TEST_INDEX_KEY2);
200 EXPECT_EQ(ret, HC_SUCCESS);
201
202 ret = manager->savePseudonymId(
203 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, TEST_REAL_INFO, TEST_DEVICE_ID, TEST_INDEX_KEY2);
204 EXPECT_EQ(ret, HC_SUCCESS);
205
206 ret = manager->savePseudonymId(
207 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID2, TEST_REAL_INFO2, TEST_DEVICE_ID2, TEST_INDEX_KEY);
208 EXPECT_EQ(ret, HC_SUCCESS);
209
210 ret = manager->deletePseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY);
211 EXPECT_EQ(ret, HC_SUCCESS);
212
213 ret = manager->deletePseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY2);
214 EXPECT_EQ(ret, HC_SUCCESS);
215 }
216
217 HWTEST_F(PrivacyEnhancementTest, DeleteAllPseudonymIdTest001, TestSize.Level0)
218 {
219 PseudonymManager *manager = GetPseudonymInstance();
220 ASSERT_NE(manager, nullptr);
221
222 int32_t ret = manager->deleteAllPseudonymId(DEFAULT_OS_ACCOUNT, nullptr);
223 EXPECT_NE(ret, HC_SUCCESS);
224
225 ret = manager->savePseudonymId(
226 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, TEST_REAL_INFO, TEST_DEVICE_ID, TEST_INDEX_KEY);
227 EXPECT_EQ(ret, HC_SUCCESS);
228
229 ret = manager->savePseudonymId(
230 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID2, TEST_REAL_INFO2, TEST_DEVICE_ID, TEST_INDEX_KEY2);
231 EXPECT_EQ(ret, HC_SUCCESS);
232
233 ret = manager->deleteAllPseudonymId(DEFAULT_OS_ACCOUNT, TEST_DEVICE_ID);
234 EXPECT_EQ(ret, HC_SUCCESS);
235 }
236
237 HWTEST_F(PrivacyEnhancementTest, DeletePseudonymIdTest001, TestSize.Level0)
238 {
239 PseudonymManager *manager = GetPseudonymInstance();
240 ASSERT_NE(manager, nullptr);
241
242 int32_t ret = manager->deletePseudonymId(DEFAULT_OS_ACCOUNT, nullptr);
243 EXPECT_NE(ret, HC_SUCCESS);
244
245 ret = manager->savePseudonymId(
246 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, TEST_REAL_INFO, TEST_DEVICE_ID, TEST_INDEX_KEY);
247 EXPECT_EQ(ret, HC_SUCCESS);
248
249 ret = manager->deletePseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY);
250 EXPECT_EQ(ret, HC_SUCCESS);
251 }
252
253 HWTEST_F(PrivacyEnhancementTest, IsNeedRefreshPseudonymIdTest001, TestSize.Level0)
254 {
255 PseudonymManager *manager = GetPseudonymInstance();
256 ASSERT_NE(manager, nullptr);
257
258 int32_t ret = manager->isNeedRefreshPseudonymId(DEFAULT_OS_ACCOUNT, nullptr);
259 EXPECT_NE(ret, HC_SUCCESS);
260
261 ret = manager->savePseudonymId(
262 DEFAULT_OS_ACCOUNT, TEST_PSEUDONYM_ID, TEST_REAL_INFO, TEST_DEVICE_ID, TEST_INDEX_KEY);
263 EXPECT_EQ(ret, HC_SUCCESS);
264
265 ret = manager->isNeedRefreshPseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY);
266 EXPECT_EQ(ret, HC_SUCCESS);
267
268 ret = manager->deletePseudonymId(DEFAULT_OS_ACCOUNT, TEST_INDEX_KEY);
269 EXPECT_EQ(ret, HC_SUCCESS);
270 }
271 }