1 /*
2 * Copyright (c) 2021 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 <cstddef>
18 #include <cstdint>
19 #include <iostream>
20 #include <cstdio>
21 #include "tee_get_native_cert.h"
22 #include "tcu_authentication.h"
23 #include "tee_auth_system.h"
24 #include "accesstoken_kit.h"
25 #include "if_system_ability_manager.h"
26 #include "ipc_skeleton.h"
27 #include "iservice_registry.h"
28 #include "system_ability_definition.h"
29 #include "bundle_mgr_mini_proxy.h"
30 #include "bundle_mgr_stub.h"
31
32 using namespace testing::ext;
33 using namespace testing;
34 using namespace OHOS;
35 using namespace OHOS::Security::AccessToken;
36 using namespace OHOS::AppExecFwk;
37
38 class AuthenticationTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 };
45
SetUpTestCase(void)46 void AuthenticationTest::SetUpTestCase(void)
47 {
48 printf("SetUp\n");
49 }
50
TearDownTestCase(void)51 void AuthenticationTest::TearDownTestCase(void)
52 {
53 printf("SetUpTestCase\n");
54 }
55
SetUp(void)56 void AuthenticationTest::SetUp(void)
57 {
58 printf("TearDownTestCase\n");
59 }
60
TearDown(void)61 void AuthenticationTest::TearDown(void)
62 {
63 printf("TearDown\n");
64 }
65 namespace {
66 HWTEST_F(AuthenticationTest, ReadCmdLine_001, TestSize.Level1)
67 {
68 int caPid = 0;
69 char path[4] = { 0 };
70 size_t pathLen = 4;
71
72 int ret = TeeGetPkgName(caPid, path, pathLen);
73 EXPECT_TRUE(ret != 0);
74 }
75
76 HWTEST_F(AuthenticationTest, TeeGetPkgName_001, TestSize.Level1)
77 {
78 int caPid = 0;
79 char path[4] = { 0 };
80 size_t pathLen = 4;
81
82 int ret = TeeGetPkgName(caPid, nullptr, MAX_PATH_LENGTH + 1);
83 EXPECT_TRUE(ret != 0);
84
85 ret = TeeGetPkgName(caPid, path, MAX_PATH_LENGTH + 1);
86 EXPECT_TRUE(ret != 0);
87
88 ret = TeeGetPkgName(caPid, path, 0);
89 EXPECT_TRUE(ret != 0);
90
91 caPid = 1;
92 ret = TeeGetPkgName(caPid, path, pathLen);
93 EXPECT_TRUE(ret != 0);
94 }
95
96 HWTEST_F(AuthenticationTest, TeeGetNativeCert_001, TestSize.Level1)
97 {
98 uint8_t buffer[MAX_PATH_LENGTH] = { 0 };
99 uint32_t len = MAX_PATH_LENGTH;
100 int caPid = 1;
101 unsigned int caUid = 0;
102
103 int ret = TeeGetNativeCert(caPid, caUid, nullptr, nullptr);
104 EXPECT_TRUE(ret != 0);
105
106 ret = TeeGetNativeCert(caPid, caUid, &len, nullptr);
107 EXPECT_TRUE(ret != 0);
108
109 ret = TeeGetNativeCert(caPid, caUid, &len, buffer);
110 EXPECT_TRUE(ret == 0);
111 }
112
113 HWTEST_F(AuthenticationTest, TcuAuthentication_001, TestSize.Level1)
114 {
115 int ret = TcuAuthentication(HASH_TYPE_SYSTEM);
116 EXPECT_TRUE(ret != 0);
117
118 ret = TcuAuthentication(HASH_TYPE_VENDOR);
119 EXPECT_TRUE(ret != 0);
120 }
121
122 HWTEST_F(AuthenticationTest, ConstructSelfAuthInfo_ConstructNativeCaInfoFromToken_001, TestSize.Level1)
123 {
124 // ConstructSelfAuthInfo
125 int32_t ret = ConstructSelfAuthInfo(nullptr);
126 EXPECT_TRUE(ret != 0);
127 uint32_t selfTokenID = 1;
128
129 IPCSkeleton::obj = new MockIPCSkeleton();
130 SystemAbilityManagerClient::objSaMgrC = new MockSystemAbilityManagerClientMid();
131 SystemAbilityManagerClient::objISaMgr = new ISystemAbilityManager();
132 AccessTokenKit::mockKitIntfObj = new MockAccessTokenKitInterface();
133
134 // ConstructNativeCaInfoFromToken
135 EXPECT_CALL(*(IPCSkeleton::obj), GetSelfTokenID()).WillOnce(Return(selfTokenID));
136 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC), GetSystemAbilityManager()).WillOnce(Return(nullptr));
137 CaAuthInfo caInfo = { .certs = {0}, .pid = 0, .uid = 0 };
138 ret = ConstructSelfAuthInfo(&caInfo);
139 EXPECT_TRUE(ret != 0);
140
141 EXPECT_CALL(*(IPCSkeleton::obj), GetSelfTokenID()).WillOnce(Return(selfTokenID));
142 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC),
143 GetSystemAbilityManager()).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
144 EXPECT_CALL(*(SystemAbilityManagerClient::objISaMgr), CheckSystemAbility(_)).WillOnce(Return(nullptr));
145 ret = ConstructSelfAuthInfo(&caInfo);
146 EXPECT_TRUE(ret != -1);
147
148 EXPECT_CALL(*(IPCSkeleton::obj), GetSelfTokenID()).WillOnce(Return(selfTokenID));
149 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC),
150 GetSystemAbilityManager()).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
151 EXPECT_CALL(*(SystemAbilityManagerClient::objISaMgr),
152 CheckSystemAbility(_)).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
153 EXPECT_CALL(*(AccessTokenKit::mockKitIntfObj), GetNativeTokenInfo(_, _)).WillRepeatedly(Return(-1));
154 ret = ConstructSelfAuthInfo(&caInfo);
155 EXPECT_TRUE(ret != 0);
156
157 EXPECT_CALL(*(IPCSkeleton::obj), GetSelfTokenID()).WillOnce(Return(selfTokenID));
158 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC),
159 GetSystemAbilityManager()).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
160 EXPECT_CALL(*(SystemAbilityManagerClient::objISaMgr),
161 CheckSystemAbility(_)).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
162 EXPECT_CALL(*(AccessTokenKit::mockKitIntfObj), GetNativeTokenInfo(_, _)).WillRepeatedly(Return(-1));
163 ret = ConstructSelfAuthInfo(&caInfo);
164 EXPECT_TRUE(ret != 0);
165
166 delete(IPCSkeleton::obj);
167 delete(SystemAbilityManagerClient::objSaMgrC);
168 delete(SystemAbilityManagerClient::objISaMgr);
169 delete(AccessTokenKit::mockKitIntfObj);
170
171 IPCSkeleton::obj = nullptr;
172 SystemAbilityManagerClient::objSaMgrC = nullptr;
173 SystemAbilityManagerClient::objISaMgr = nullptr;
174 AccessTokenKit::mockKitIntfObj = nullptr;
175 }
176
177 HWTEST_F(AuthenticationTest, ConstructNativeCaInfoFromToken_002, TestSize.Level1)
178 {
179 IPCSkeleton::obj = new MockIPCSkeleton();
180 SystemAbilityManagerClient::objSaMgrC = new MockSystemAbilityManagerClientMid();
181 SystemAbilityManagerClient::objISaMgr = new ISystemAbilityManager();
182 AccessTokenKit::mockKitIntfObj = new MockAccessTokenKitInterface();
183
184 uint32_t selfTokenID = 1;
185 CaAuthInfo caInfo = { .certs = {0}, .pid = 0, .uid = 0 };
186 AccessTokenIDInner innerToken;
187 innerToken.tokenUniqueID = 1;
188 selfTokenID = *(reinterpret_cast<uint32_t *>(&innerToken));
189 EXPECT_CALL(*(IPCSkeleton::obj), GetSelfTokenID()).WillOnce(Return(selfTokenID));
190 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC),
191 GetSystemAbilityManager()).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
192 EXPECT_CALL(*(SystemAbilityManagerClient::objISaMgr),
193 CheckSystemAbility(_)).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
194 EXPECT_CALL(*(AccessTokenKit::mockKitIntfObj), GetNativeTokenInfo(_, _)).WillOnce(Return(0));
195 int32_t ret = ConstructSelfAuthInfo(&caInfo);
196 EXPECT_TRUE(ret != 0);
197
198 innerToken.tokenUniqueID = 2;
199 selfTokenID = *(reinterpret_cast<uint32_t *>(&innerToken));
200 EXPECT_CALL(*(IPCSkeleton::obj), GetSelfTokenID()).WillOnce(Return(selfTokenID));
201 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC),
202 GetSystemAbilityManager()).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
203 EXPECT_CALL(*(SystemAbilityManagerClient::objISaMgr),
204 CheckSystemAbility(_)).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
205 EXPECT_CALL(*(AccessTokenKit::mockKitIntfObj), GetNativeTokenInfo(_, _)).WillOnce(Return(0));
206 ret = ConstructSelfAuthInfo(&caInfo);
207 EXPECT_TRUE(ret != -1);
208
209 innerToken.tokenUniqueID = 3;
210 selfTokenID = *(reinterpret_cast<uint32_t *>(&innerToken));
211 EXPECT_CALL(*(IPCSkeleton::obj), GetSelfTokenID()).WillOnce(Return(selfTokenID));
212 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC),
213 GetSystemAbilityManager()).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
214 EXPECT_CALL(*(SystemAbilityManagerClient::objISaMgr),
215 CheckSystemAbility(_)).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
216 EXPECT_CALL(*(AccessTokenKit::mockKitIntfObj), GetNativeTokenInfo(_, _)).WillOnce(Return(0));
217 ret = ConstructSelfAuthInfo(&caInfo);
218 EXPECT_TRUE(ret == -1);
219
220 delete(IPCSkeleton::obj);
221 delete(SystemAbilityManagerClient::objSaMgrC);
222 delete(SystemAbilityManagerClient::objISaMgr);
223 delete(AccessTokenKit::mockKitIntfObj);
224
225 IPCSkeleton::obj = nullptr;
226 SystemAbilityManagerClient::objSaMgrC = nullptr;
227 SystemAbilityManagerClient::objISaMgr = nullptr;
228 AccessTokenKit::mockKitIntfObj = nullptr;
229 }
230
231 HWTEST_F(AuthenticationTest, ConstructCaAuthInfo_001, TestSize.Level1)
232 {
233 uint32_t tokenID = 0;
234 int32_t ret = ConstructCaAuthInfo(tokenID, nullptr);
235 EXPECT_TRUE(ret != 0);
236
237 AccessTokenIDInner innerToken = { 0 };
238 innerToken.tokenUniqueID = 0;
239 innerToken.type = 0;
240 tokenID = *(reinterpret_cast<uint32_t *>(&innerToken));
241 CaAuthInfo caInfo = { { 0 } };
242 SystemAbilityManagerClient::objISaMgr = new ISystemAbilityManager();
243 SystemAbilityManagerClient::objSaMgrC = new MockSystemAbilityManagerClientMid();
244 sptr<IRemoteObject> object = new BundleMgrStub();
245 IPCSkeleton::obj = new MockIPCSkeleton();
246 EXPECT_CALL(*(IPCSkeleton::obj), GetCallingUid()).WillOnce(Return(200000));
247 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC),
248 GetSystemAbilityManager()).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
249 EXPECT_CALL(*(SystemAbilityManagerClient::objISaMgr),
250 GetSystemAbility(_)).WillOnce(Return(object));
251
252 ret = ConstructCaAuthInfo(tokenID, &caInfo);
253 EXPECT_TRUE(ret != 0);
254
255 innerToken.tokenUniqueID = 1;
256 innerToken.type = 1;
257 tokenID = *(reinterpret_cast<uint32_t *>(&innerToken));
258 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC), GetSystemAbilityManager()).WillOnce(Return(nullptr));
259 ret = ConstructCaAuthInfo(tokenID, &caInfo);
260 EXPECT_TRUE(ret != 0);
261
262 innerToken.tokenUniqueID = 2;
263 innerToken.type = 2;
264 tokenID = *(reinterpret_cast<uint32_t *>(&innerToken));
265 ret = ConstructCaAuthInfo(tokenID, &caInfo);
266 EXPECT_TRUE(ret != -1);
267
268 innerToken.type = -1;
269 tokenID = *(reinterpret_cast<uint32_t *>(&innerToken));
270 ret = ConstructCaAuthInfo(tokenID, &caInfo);
271 EXPECT_TRUE(ret != 0);
272
273 delete(AccessTokenKit::mockKitIntfObj);
274 delete(SystemAbilityManagerClient::objSaMgrC);
275 delete(SystemAbilityManagerClient::objISaMgr);
276 delete(IPCSkeleton::obj);
277 AccessTokenKit::mockKitIntfObj = nullptr;
278 SystemAbilityManagerClient::objSaMgrC = nullptr;
279 SystemAbilityManagerClient::objISaMgr = nullptr;
280 IPCSkeleton::obj = nullptr;
281 }
282
283 HWTEST_F(AuthenticationTest, ConstructHapCaInfoFromToken_001, TestSize.Level1)
284 {
285 AccessTokenIDInner innerToken = { 0 };
286 innerToken.tokenUniqueID = 0;
287 innerToken.type = 0;
288 uint32_t tokenID = *(reinterpret_cast<uint32_t *>(&innerToken));
289 CaAuthInfo caInfo = { { 0 } };
290 SystemAbilityManagerClient::objISaMgr = new ISystemAbilityManager();
291 SystemAbilityManagerClient::objSaMgrC = new MockSystemAbilityManagerClientMid();
292 sptr<IRemoteObject> object = new BundleMgrStub();
293 IPCSkeleton::obj = new MockIPCSkeleton();
294 EXPECT_CALL(*(IPCSkeleton::obj), GetCallingUid()).WillOnce(Return(200000));
295 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC),
296 GetSystemAbilityManager()).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
297 EXPECT_CALL(*(SystemAbilityManagerClient::objISaMgr),
298 GetSystemAbility(_)).WillOnce(Return(object));
299 int32_t ret = ConstructCaAuthInfo(tokenID, &caInfo);
300 EXPECT_TRUE(ret != 0);
301 printf("1\n");
302 innerToken.tokenUniqueID = 1;
303 innerToken.type = 0;
304 tokenID = *(reinterpret_cast<uint32_t *>(&innerToken));
305 EXPECT_CALL(*(IPCSkeleton::obj), GetCallingUid()).WillOnce(Return(0));
306 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC),
307 GetSystemAbilityManager()).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
308 EXPECT_CALL(*(SystemAbilityManagerClient::objISaMgr),
309 GetSystemAbility(_)).WillOnce(Return(object));
310 ret = ConstructCaAuthInfo(tokenID, &caInfo);
311 EXPECT_TRUE(ret != 0);
312 printf("2\n");
313 innerToken.tokenUniqueID = 2;
314 innerToken.type = 0;
315 tokenID = *(reinterpret_cast<uint32_t *>(&innerToken));
316 EXPECT_CALL(*(IPCSkeleton::obj), GetCallingUid()).WillOnce(Return(-1));
317 EXPECT_CALL(*(SystemAbilityManagerClient::objSaMgrC),
318 GetSystemAbilityManager()).WillOnce(Return(SystemAbilityManagerClient::objISaMgr));
319 EXPECT_CALL(*(SystemAbilityManagerClient::objISaMgr),
320 GetSystemAbility(_)).WillOnce(Return(object));
321 ret = ConstructCaAuthInfo(tokenID, &caInfo);
322 EXPECT_TRUE(ret != 0);
323 printf("3\n");
324 delete(AccessTokenKit::mockKitIntfObj);
325 delete(SystemAbilityManagerClient::objSaMgrC);
326 delete(SystemAbilityManagerClient::objISaMgr);
327 delete(IPCSkeleton::obj);
328 SystemAbilityManagerClient::objSaMgrC = nullptr;
329 SystemAbilityManagerClient::objISaMgr = nullptr;
330 AccessTokenKit::mockKitIntfObj = nullptr;
331 IPCSkeleton::obj = nullptr;
332 }
333
334 HWTEST_F(AuthenticationTest, TEEGetNativeSACaInfo_001, TestSize.Level1)
335 {
336 int32_t ret = TEEGetNativeSACaInfo(nullptr, nullptr, 0);
337 EXPECT_TRUE(ret != 0);
338
339 CaAuthInfo caInfo = { .certs="TEEGetNativeSACaInfo_001", .uid= 1};
340 uint8_t buf[1024] = { 0 };
341 uint32_t bufLen = sizeof(buf);
342 ret = TEEGetNativeSACaInfo(&caInfo, nullptr, 0);
343 EXPECT_TRUE(ret != 0);
344
345 ret = TEEGetNativeSACaInfo(&caInfo, buf, 0);
346 EXPECT_TRUE(ret != 0);
347
348 ret = TEEGetNativeSACaInfo(&caInfo, buf, bufLen);
349 EXPECT_TRUE(ret != -1);
350 }
351 }