1 /*
2 * Copyright (C) 2022 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 "alg_loader.h"
20 #include "asy_token_manager.h"
21 #include "common_defs.h"
22 #include "device_auth.h"
23 #include "device_auth_defines.h"
24 #include "hc_dev_info_mock.h"
25 #include "json_utils.h"
26 #include "securec.h"
27 #include "sym_token_manager.h"
28
29 using namespace std;
30 using namespace testing::ext;
31
32 namespace {
33 #define TEST_HKS_DATA_PATH DEVICE_AUTH_TEST_HKS_DATA_PATH "/maindata/+0+0+0+0"
34
35 static const std::string TEST_SYM_USER_ID = "1234ABCD";
36 static const std::string TEST_SYM_DEVICE_ID = "TestAuthId";
37 static const std::string TEST_SYM_AUTH_CODE = "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b";
38 static const std::string TEST_SYM_USER_ID2 = "DCBA4321";
39 static const std::string TEST_SYM_DEVICE_ID2 = "TestAuthId2";
40 static const std::string TEST_SYM_AUTH_CODE2 = "2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335";
41 static const std::string TEST_SYM_USER_ID3 = "1234ABCDE";
42 static const std::string TEST_SYM_DEVICE_ID3 = "TestAuthId3";
43
44 static const int TEST_DEV_AUTH_BUFFER_SIZE = 128;
45
46 class CredsManagerTest : public testing::Test {
47 public:
48 static void SetUpTestCase();
49 static void TearDownTestCase();
50 void SetUp();
51 void TearDown();
52 };
53
SetUpTestCase()54 void CredsManagerTest::SetUpTestCase() {}
TearDownTestCase()55 void CredsManagerTest::TearDownTestCase() {}
56
RemoveDir(const char * path)57 static void RemoveDir(const char *path)
58 {
59 char strBuf[TEST_DEV_AUTH_BUFFER_SIZE] = { 0 };
60 if (path == nullptr) {
61 return;
62 }
63 if (sprintf_s(strBuf, sizeof(strBuf) - 1, "rm -rf %s", path) < 0) {
64 return;
65 }
66 system(strBuf);
67 }
68
RemoveHuks(void)69 static void RemoveHuks(void)
70 {
71 RemoveDir(TEST_HKS_DATA_PATH);
72 }
73
DeleteDatabase()74 static void DeleteDatabase()
75 {
76 const char *groupPath = "/data/service/el1/public/deviceauthMock";
77 RemoveDir(groupPath);
78 RemoveHuks();
79 }
80
SetUp()81 void CredsManagerTest::SetUp()
82 {
83 DeleteDatabase();
84 int32_t ret = InitDeviceAuthService();
85 ASSERT_EQ(ret, HC_SUCCESS);
86 }
87
TearDown()88 void CredsManagerTest::TearDown()
89 {
90 DestroyDeviceAuthService();
91 }
92
93 HWTEST_F(CredsManagerTest, CredsManagerTest001, TestSize.Level0)
94 {
95 SymTokenManager *tokenManager = GetSymTokenManager();
96 ASSERT_NE(tokenManager, nullptr);
97
98 CJson *json = CreateJson();
99 EXPECT_NE(json, nullptr);
100 (void)AddStringToJson(json, FIELD_USER_ID, TEST_SYM_USER_ID.c_str());
101 (void)AddStringToJson(json, FIELD_DEVICE_ID, TEST_SYM_DEVICE_ID.c_str());
102 (void)AddStringToJson(json, FIELD_AUTH_CODE, TEST_SYM_AUTH_CODE.c_str());
103 SetAccountStorageTest(true);
104
105 int32_t ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
106 EXPECT_NE(ret, HC_SUCCESS);
107
108 SetAccountStorageTest(false);
109 FreeJson(json);
110 }
111
112 HWTEST_F(CredsManagerTest, CredsManagerTest002, TestSize.Level0)
113 {
114 SymTokenManager *tokenManager = GetSymTokenManager();
115 ASSERT_NE(tokenManager, nullptr);
116
117 int32_t ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, nullptr);
118 EXPECT_EQ(ret, HC_ERR_NULL_PTR);
119
120 CJson *json = CreateJson();
121 EXPECT_NE(json, nullptr);
122 ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
123 EXPECT_EQ(ret, HC_ERR_ALLOC_MEMORY);
124
125 (void)AddStringToJson(json, FIELD_USER_ID, TEST_SYM_USER_ID.c_str());
126 ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
127 EXPECT_EQ(ret, HC_ERR_ALLOC_MEMORY);
128
129 // only add the token to vector, import key failed
130 (void)AddStringToJson(json, FIELD_DEVICE_ID, TEST_SYM_DEVICE_ID.c_str());
131 ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
132 EXPECT_EQ(ret, HC_ERR_JSON_GET);
133
134 (void)AddStringToJson(json, FIELD_AUTH_CODE, TEST_SYM_AUTH_CODE.c_str());
135 ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
136 EXPECT_EQ(ret, HC_SUCCESS);
137
138 // replace the existed one
139 ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
140 EXPECT_EQ(ret, HC_SUCCESS);
141
142 FreeJson(json);
143 }
144
145 HWTEST_F(CredsManagerTest, CredsManagerTest003, TestSize.Level0)
146 {
147 SymTokenManager *tokenManager = GetSymTokenManager();
148 ASSERT_NE(tokenManager, nullptr);
149
150 Uint8Buff keyAlias = { nullptr, 0 };
151 int32_t ret = tokenManager->generateKeyAlias(nullptr, TEST_SYM_DEVICE_ID.c_str(), &keyAlias);
152 EXPECT_EQ(ret, HC_ERR_NULL_PTR);
153
154 ret = tokenManager->generateKeyAlias(TEST_SYM_USER_ID.c_str(), nullptr, &keyAlias);
155 EXPECT_EQ(ret, HC_ERR_NULL_PTR);
156
157 ret = tokenManager->generateKeyAlias(TEST_SYM_USER_ID.c_str(), TEST_SYM_DEVICE_ID.c_str(), nullptr);
158 EXPECT_EQ(ret, HC_ERR_NULL_PTR);
159 }
160
161 HWTEST_F(CredsManagerTest, CredsManagerTest004, TestSize.Level0)
162 {
163 SymTokenManager *tokenManager = GetSymTokenManager();
164 ASSERT_NE(tokenManager, nullptr);
165
166 CJson *json = CreateJson();
167 EXPECT_NE(json, nullptr);
168 (void)AddStringToJson(json, FIELD_USER_ID, TEST_SYM_USER_ID.c_str());
169 (void)AddStringToJson(json, FIELD_DEVICE_ID, TEST_SYM_DEVICE_ID.c_str());
170 (void)AddStringToJson(json, FIELD_AUTH_CODE, TEST_SYM_AUTH_CODE.c_str());
171 int32_t ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
172 EXPECT_EQ(ret, HC_SUCCESS);
173
174 (void)AddStringToJson(json, FIELD_USER_ID, TEST_SYM_USER_ID2.c_str());
175 (void)AddStringToJson(json, FIELD_DEVICE_ID, TEST_SYM_DEVICE_ID2.c_str());
176 (void)AddStringToJson(json, FIELD_AUTH_CODE, TEST_SYM_AUTH_CODE2.c_str());
177 ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
178 EXPECT_EQ(ret, HC_SUCCESS);
179
180 // userId is null, delete failed
181 ret = tokenManager->deleteToken(DEFAULT_OS_ACCOUNT, nullptr, TEST_SYM_DEVICE_ID.c_str());
182 EXPECT_EQ(ret, HC_ERR_NULL_PTR);
183
184 // deviceId is null, delete failed
185 ret = tokenManager->deleteToken(DEFAULT_OS_ACCOUNT, TEST_SYM_USER_ID.c_str(), nullptr);
186 EXPECT_EQ(ret, HC_ERR_NULL_PTR);
187
188 // delete the second token first
189 ret = tokenManager->deleteToken(DEFAULT_OS_ACCOUNT, TEST_SYM_USER_ID2.c_str(), TEST_SYM_DEVICE_ID2.c_str());
190 EXPECT_EQ(ret, HC_SUCCESS);
191
192 // delete non-existent token
193 ret = tokenManager->deleteToken(DEFAULT_OS_ACCOUNT, TEST_SYM_USER_ID3.c_str(), TEST_SYM_DEVICE_ID3.c_str());
194 EXPECT_EQ(ret, HC_ERR_NULL_PTR);
195
196 // set account storage null, expect result: save to file failed after delete from vector
197 SetAccountStorageTest(true);
198 ret = tokenManager->deleteToken(DEFAULT_OS_ACCOUNT, TEST_SYM_USER_ID.c_str(), TEST_SYM_DEVICE_ID.c_str());
199 SetAccountStorageTest(false);
200 EXPECT_NE(ret, HC_SUCCESS);
201
202 FreeJson(json);
203 }
204 }