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 static const std::string TEST_SYM_USER_ID = "1234ABCD";
34 static const std::string TEST_SYM_DEVICE_ID = "TestAuthId";
35 static const std::string TEST_SYM_AUTH_CODE = "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b";
36 static const std::string TEST_SYM_USER_ID2 = "DCBA4321";
37 static const std::string TEST_SYM_DEVICE_ID2 = "TestAuthId2";
38 static const std::string TEST_SYM_AUTH_CODE2 = "2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335";
39 static const std::string TEST_SYM_USER_ID3 = "1234ABCDE";
40 static const std::string TEST_SYM_DEVICE_ID3 = "TestAuthId3";
41 static const std::string TEST_GROUP_DATA_PATH = "/data/service/el1/public/deviceauthMock";
42 static const std::string TEST_HKS_MAIN_DATA_PATH = "/data/service/el1/public/huks_service/tmp/+0+0+0+0";
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 
DeleteDatabase()69 static void DeleteDatabase()
70 {
71     RemoveDir(TEST_GROUP_DATA_PATH.c_str());
72     RemoveDir(TEST_HKS_MAIN_DATA_PATH.c_str());
73 }
74 
SetUp()75 void CredsManagerTest::SetUp()
76 {
77     DeleteDatabase();
78     int32_t ret = InitDeviceAuthService();
79     ASSERT_EQ(ret, HC_SUCCESS);
80 }
81 
TearDown()82 void CredsManagerTest::TearDown()
83 {
84     DestroyDeviceAuthService();
85 }
86 
87 HWTEST_F(CredsManagerTest, CredsManagerTest001, TestSize.Level0)
88 {
89     SymTokenManager *tokenManager = GetSymTokenManager();
90     ASSERT_NE(tokenManager, nullptr);
91 
92     CJson *json = CreateJson();
93     EXPECT_NE(json, nullptr);
94     (void)AddStringToJson(json, FIELD_USER_ID, TEST_SYM_USER_ID.c_str());
95     (void)AddStringToJson(json, FIELD_DEVICE_ID, TEST_SYM_DEVICE_ID.c_str());
96     (void)AddStringToJson(json, FIELD_AUTH_CODE, TEST_SYM_AUTH_CODE.c_str());
97     SetAccountStorageTest(true);
98 
99     int32_t ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
100     EXPECT_NE(ret, HC_SUCCESS);
101 
102     SetAccountStorageTest(false);
103     FreeJson(json);
104 }
105 
106 HWTEST_F(CredsManagerTest, CredsManagerTest002, TestSize.Level0)
107 {
108     SymTokenManager *tokenManager = GetSymTokenManager();
109     ASSERT_NE(tokenManager, nullptr);
110 
111     int32_t ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, nullptr);
112     EXPECT_EQ(ret, HC_ERR_NULL_PTR);
113 
114     CJson *json = CreateJson();
115     EXPECT_NE(json, nullptr);
116     ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
117     EXPECT_EQ(ret, HC_ERR_ALLOC_MEMORY);
118 
119     (void)AddStringToJson(json, FIELD_USER_ID, TEST_SYM_USER_ID.c_str());
120     ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
121     EXPECT_EQ(ret, HC_ERR_ALLOC_MEMORY);
122 
123     // only add the token to vector, import key failed
124     (void)AddStringToJson(json, FIELD_DEVICE_ID, TEST_SYM_DEVICE_ID.c_str());
125     ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
126     EXPECT_EQ(ret, HC_ERR_JSON_GET);
127 
128     (void)AddStringToJson(json, FIELD_AUTH_CODE, TEST_SYM_AUTH_CODE.c_str());
129     ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
130     EXPECT_EQ(ret, HC_SUCCESS);
131 
132     // replace the existed one
133     ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
134     EXPECT_EQ(ret, HC_SUCCESS);
135 
136     FreeJson(json);
137 }
138 
139 HWTEST_F(CredsManagerTest, CredsManagerTest003, TestSize.Level0)
140 {
141     SymTokenManager *tokenManager = GetSymTokenManager();
142     ASSERT_NE(tokenManager, nullptr);
143 
144     Uint8Buff keyAlias = { nullptr, 0 };
145     int32_t ret = tokenManager->generateKeyAlias(nullptr, TEST_SYM_DEVICE_ID.c_str(), &keyAlias);
146     EXPECT_EQ(ret, HC_ERR_NULL_PTR);
147 
148     ret = tokenManager->generateKeyAlias(TEST_SYM_USER_ID.c_str(), nullptr, &keyAlias);
149     EXPECT_EQ(ret, HC_ERR_NULL_PTR);
150 
151     ret = tokenManager->generateKeyAlias(TEST_SYM_USER_ID.c_str(), TEST_SYM_DEVICE_ID.c_str(), nullptr);
152     EXPECT_EQ(ret, HC_ERR_NULL_PTR);
153 }
154 
155 HWTEST_F(CredsManagerTest, CredsManagerTest004, TestSize.Level0)
156 {
157     SymTokenManager *tokenManager = GetSymTokenManager();
158     ASSERT_NE(tokenManager, nullptr);
159 
160     CJson *json = CreateJson();
161     EXPECT_NE(json, nullptr);
162     (void)AddStringToJson(json, FIELD_USER_ID, TEST_SYM_USER_ID.c_str());
163     (void)AddStringToJson(json, FIELD_DEVICE_ID, TEST_SYM_DEVICE_ID.c_str());
164     (void)AddStringToJson(json, FIELD_AUTH_CODE, TEST_SYM_AUTH_CODE.c_str());
165     int32_t ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
166     EXPECT_EQ(ret, HC_SUCCESS);
167 
168     (void)AddStringToJson(json, FIELD_USER_ID, TEST_SYM_USER_ID2.c_str());
169     (void)AddStringToJson(json, FIELD_DEVICE_ID, TEST_SYM_DEVICE_ID2.c_str());
170     (void)AddStringToJson(json, FIELD_AUTH_CODE, TEST_SYM_AUTH_CODE2.c_str());
171     ret = tokenManager->addToken(DEFAULT_OS_ACCOUNT, IMPORT_TRUSTED_CREDENTIALS, json);
172     EXPECT_EQ(ret, HC_SUCCESS);
173 
174     // userId is null, delete failed
175     ret = tokenManager->deleteToken(DEFAULT_OS_ACCOUNT, nullptr, TEST_SYM_DEVICE_ID.c_str());
176     EXPECT_EQ(ret, HC_ERR_NULL_PTR);
177 
178     // deviceId is null, delete failed
179     ret = tokenManager->deleteToken(DEFAULT_OS_ACCOUNT, TEST_SYM_USER_ID.c_str(), nullptr);
180     EXPECT_EQ(ret, HC_ERR_NULL_PTR);
181 
182     // delete the second token first
183     ret = tokenManager->deleteToken(DEFAULT_OS_ACCOUNT, TEST_SYM_USER_ID2.c_str(), TEST_SYM_DEVICE_ID2.c_str());
184     EXPECT_EQ(ret, HC_SUCCESS);
185 
186     // delete non-existent token
187     ret = tokenManager->deleteToken(DEFAULT_OS_ACCOUNT, TEST_SYM_USER_ID3.c_str(), TEST_SYM_DEVICE_ID3.c_str());
188     EXPECT_EQ(ret, HC_ERR_NULL_PTR);
189 
190     // set account storage null, expect result: save to file failed after delete from vector
191     SetAccountStorageTest(true);
192     ret = tokenManager->deleteToken(DEFAULT_OS_ACCOUNT, TEST_SYM_USER_ID.c_str(), TEST_SYM_DEVICE_ID.c_str());
193     SetAccountStorageTest(false);
194     EXPECT_NE(ret, HC_SUCCESS);
195 
196     FreeJson(json);
197 }
198 }