1 /*
2 * Copyright (C) 2025 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
17 #include <cinttypes>
18 #include <cstring>
19 #include <unistd.h>
20 #include <gtest/gtest.h>
21 #include "device_auth.h"
22 #include "device_auth_defines.h"
23 #include "json_utils.h"
24 #include "securec.h"
25 #include "nativetoken_kit.h"
26 #include "token_setproc.h"
27 #include "hc_dev_info.h"
28 #include "hc_types.h"
29 #include "base/security/device_auth/services/device_auth.c"
30
31 using namespace std;
32 using namespace testing::ext;
33
34 namespace {
35 #define TEST_REQ_ID 123
36 #define TEST_REQ_ID_0 0
37 #define TEST_REQ_ID1 124
38 #define TEST_REQ_ID2 125
39 #define TEST_OS_ACCOUNT_ID 100
40 #define TEST_OS_ACCOUNT_ID_0 0
41 #define TEST_APP_ID "TestAppId"
42 #define TEST_USER_ID "testUserId"
43 #define TEST_RANDOM_LEN 16
44 #define TEST_RANDOM_VAL "17A9B0AC2C578A138C77B76B11CC0FBB"
45 #define TEST_FIELD_RANDOM_VAL "randomVal"
46 #define TEST_FIELD_LIGHTMSG "lightAccountMsg"
47
48 static const char *TEST_LIGHT_MSG =
49 "{\"randomVal\": \"17A9B0AC2C578A138C77B76B11CC0FBB\","
50 "\"version\": \"19\","
51 "\"userId\": \"12345678901234567\","
52 "\"deviceId\": \"17A9B0AC2C578A138C77\","
53 "\"devicePk\": \"17A9B0AC2C578A138C7717A9B0AC2C578A138C7717A9B0A"
54 "C2C578A138C7717A9B0AC2C578A138C7717A9B0AC2C578A138C7717A9B0AC2C578A138C7711CC0FBB\","
55 "\"pkInfoSignature\": \"17A9B0AC2C578A138C7717A9B0AC2C578A138C771"
56 "7A9B0AC2C578A138C7717A9B0AC2C578A138C7717A9B0AC2C5"
57 "78A138C7717A9B0AC2C578A138C7711CC0FBB\"}";
58
59 static const char *OUT_DATA =
60 "{\"sharedKeyVal\": \"17A9B0AC2C578A138C77B76B11CC0FBB17A9B0AC"
61 "2C578A138C77B76B11CC0FBB\",\"sharedKeyLen\": \"32\","
62 "\"randomVal\": \"17A9B0AC2C578A138C77B76B11CC0FBB\","
63 "\"randomLen\": \"16\","
64 "\"peerRandomVal\": \"17A9B0AC2C578A138C77B76B11CC0FBB\","
65 "\"peerRandomLen\": \"16\","
66 "\"peerUserId\": \"12345678901234567\"}";
67
68 static const char *SERVICE_ID = "testServiceID";
69
OnLightTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)70 static bool OnLightTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
71 {
72 (void)requestId;
73 (void)data;
74 (void)dataLen;
75 return true;
76 }
77
OnLightAuthRequest(int64_t requestId,int operationCode,const char * reqParam)78 static char *OnLightAuthRequest(int64_t requestId, int operationCode, const char *reqParam)
79 {
80 CJson *json = CreateJson();
81 AddStringToJson(json, FIELD_APP_ID, TEST_APP_ID);
82 char *returnDataStr = PackJsonToString(json);
83 FreeJson(json);
84 return returnDataStr;
85 }
86
OnLightSessionKeyReturned(int64_t requestId,const uint8_t * sessionKey,uint32_t sessionKeyLen)87 static void OnLightSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
88 {
89 (void)requestId;
90 (void)sessionKey;
91 (void)sessionKeyLen;
92 }
93
OnLightFinish(int64_t requestId,int operationCode,const char * authReturn)94 static void OnLightFinish(int64_t requestId, int operationCode, const char *authReturn)
95 {
96 (void)requestId;
97 (void)operationCode;
98 (void)authReturn;
99 }
100
OnLightError(int64_t requestId,int operationCode,int errorCode,const char * errorReturn)101 static void OnLightError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
102 {
103 (void)requestId;
104 (void)operationCode;
105 (void)errorCode;
106 (void)errorReturn;
107 }
108
109 class LaInterfaceTest : public testing::Test {
110 public:
111 static void SetUpTestCase();
112 static void TearDownTestCase();
113 void SetUp();
114 void TearDown();
115 };
116
SetUpTestCase()117 void LaInterfaceTest::SetUpTestCase() {}
TearDownTestCase()118 void LaInterfaceTest::TearDownTestCase() {}
119
SetUp()120 void LaInterfaceTest::SetUp()
121 {
122 int ret = InitDeviceAuthService();
123 EXPECT_EQ(ret, HC_SUCCESS);
124 }
125
TearDown()126 void LaInterfaceTest::TearDown()
127 {
128 DestroyDeviceAuthService();
129 }
130
131 HWTEST_F(LaInterfaceTest, LaInterfaceTest001, TestSize.Level0)
132 {
133 (void)InitDeviceAuthService();
134 const LightAccountVerifier *lightVerifier = GetLightAccountVerifierInstance();
135 ASSERT_NE(lightVerifier, nullptr);
136
137 DeviceAuthCallback laCallback = { NULL };
138 int32_t testMsgLen = HcStrlen(TEST_LIGHT_MSG) + 1;
139 DataBuff testInMsg = {(uint8_t *)TEST_LIGHT_MSG, testMsgLen};
140
141 int32_t res = lightVerifier->startLightAccountAuth(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, &laCallback);
142 ASSERT_NE(res, HC_SUCCESS);
143
144 res = lightVerifier->processLightAccountAuth(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, &testInMsg, &laCallback);
145 ASSERT_NE(res, HC_SUCCESS);
146 }
147
148 HWTEST_F(LaInterfaceTest, LaInterfaceTest002, TestSize.Level0)
149 {
150 CJson *json = CreateJson();
151 int32_t ret = AddStringToJson(json, TEST_FIELD_RANDOM_VAL, TEST_RANDOM_VAL);
152 EXPECT_EQ(ret, HC_SUCCESS);
153 CJson *out = CreateJsonFromString(OUT_DATA);
154 EXPECT_NE(out, nullptr);
155 CJson *msg = CreateJsonFromString(TEST_LIGHT_MSG);
156 EXPECT_NE(msg, nullptr);
157 ret = AddObjToJson(out, TEST_FIELD_LIGHTMSG, msg);
158 EXPECT_EQ(ret, HC_SUCCESS);
159
160 DataBuff returnRandom = {0};
161 ret = GetRandomValFromOutJson(out, &returnRandom);
162 EXPECT_EQ(ret, HC_SUCCESS);
163 ret = GetRandomValFromOutJson(nullptr, &returnRandom);
164 EXPECT_NE(ret, HC_SUCCESS);
165 ret = GetPeerRandomValFromOutJson(out, &returnRandom);
166 EXPECT_EQ(ret, HC_SUCCESS);
167 ret = GetPeerRandomValFromOutJson(nullptr, &returnRandom);
168 EXPECT_NE(ret, HC_SUCCESS);
169 DestroyDataBuff(&returnRandom);
170 FreeJson(msg);
171 FreeJson(out);
172
173 ret = LightAuthVerifySign(TEST_OS_ACCOUNT_ID, json, json);
174 EXPECT_NE(ret, HC_SUCCESS);
175
176 DeviceAuthCallback laCallback = { NULL };
177 laCallback.onTransmit = OnLightTransmit;
178 laCallback.onError = OnLightError;
179 laCallback.onSessionKeyReturned = OnLightSessionKeyReturned;
180 laCallback.onFinish = OnLightFinish;
181 laCallback.onRequest = OnLightAuthRequest;
182
183 ret = StartLightAccountAuthInner(TEST_OS_ACCOUNT_ID, TEST_REQ_ID,
184 TEST_APP_ID, &laCallback, json);
185 EXPECT_EQ(ret, HC_SUCCESS);
186 FreeJson(json);
187
188 ret = StartLightAccountAuth(TEST_OS_ACCOUNT_ID, TEST_REQ_ID,
189 TEST_APP_ID, &laCallback);
190 EXPECT_NE(ret, HC_SUCCESS);
191 }
192
193 HWTEST_F(LaInterfaceTest, LaInterfaceTest003, TestSize.Level0)
194 {
195 CJson *out = CreateJsonFromString(OUT_DATA);
196 EXPECT_NE(out, nullptr);
197 CJson *msg = CreateJsonFromString(TEST_LIGHT_MSG);
198 EXPECT_NE(msg, nullptr);
199 int32_t ret = AddObjToJson(out, TEST_FIELD_LIGHTMSG, msg);
200 EXPECT_EQ(ret, HC_SUCCESS);
201
202 DataBuff returnRandom = { 0 };
203 ret = GetRandomValFromOutJson(out, &returnRandom);
204 EXPECT_EQ(ret, HC_SUCCESS);
205
206 uint32_t hkdfSaltLen = TEST_RANDOM_LEN + TEST_RANDOM_LEN;
207 uint8_t *hkdfSalt = static_cast<uint8_t *>(HcMalloc(hkdfSaltLen, 0));
208 ret = ConstructSaltInner(returnRandom, returnRandom, hkdfSalt, hkdfSaltLen);
209 EXPECT_EQ(ret, HC_SUCCESS);
210 HcFree(hkdfSalt);
211
212 ret = GetRandomVal(out, returnRandom.data, true, &returnRandom);
213 EXPECT_EQ(ret, HC_SUCCESS);
214 ret = GetRandomVal(nullptr, returnRandom.data, true, &returnRandom);
215 EXPECT_EQ(ret, HC_SUCCESS);
216
217 ret = GetRandomVal(out, returnRandom.data, false, &returnRandom);
218 EXPECT_EQ(ret, HC_SUCCESS);
219 ret = GetRandomVal(nullptr, returnRandom.data, false, &returnRandom);
220 EXPECT_NE(ret, HC_SUCCESS);
221
222 Uint8Buff hkdfSaltBuff = { 0 };
223 ret = ConstructSalt(out, returnRandom.data, &hkdfSaltBuff, true);
224 EXPECT_EQ(ret, HC_SUCCESS);
225 ret = ConstructSalt(out, returnRandom.data, &hkdfSaltBuff, false);
226 EXPECT_EQ(ret, HC_SUCCESS);
227 ret = ConstructSalt(nullptr, returnRandom.data, &hkdfSaltBuff, true);
228 EXPECT_NE(ret, HC_SUCCESS);
229 ret = ConstructSalt(nullptr, returnRandom.data, &hkdfSaltBuff, false);
230 EXPECT_NE(ret, HC_SUCCESS);
231 HcFree(hkdfSaltBuff.val);
232 DestroyDataBuff(&returnRandom);
233
234 Uint8Buff keyInfoBuff = { 0 };
235 ret = ConstructKeyInfo(out, SERVICE_ID, &keyInfoBuff, true);
236 EXPECT_EQ(ret, HC_SUCCESS);
237 ret = ConstructKeyInfo(out, SERVICE_ID, &keyInfoBuff, false);
238 EXPECT_EQ(ret, HC_SUCCESS);
239 HcFree(keyInfoBuff.val);
240 FreeJson(msg);
241 FreeJson(out);
242 }
243
244 HWTEST_F(LaInterfaceTest, LaInterfaceTest004, TestSize.Level0)
245 {
246 CJson *out = CreateJsonFromString(OUT_DATA);
247 EXPECT_NE(out, nullptr);
248 CJson *msg = CreateJsonFromString(TEST_LIGHT_MSG);
249 EXPECT_NE(msg, nullptr);
250 int32_t ret = AddObjToJson(out, TEST_FIELD_LIGHTMSG, msg);
251 EXPECT_EQ(ret, HC_SUCCESS);
252
253 DataBuff returnRandom = { 0 };
254 ret = GetRandomValFromOutJson(out, &returnRandom);
255 EXPECT_EQ(ret, HC_SUCCESS);
256
257 DeviceAuthCallback laCallback = { NULL };
258 laCallback.onTransmit = OnLightTransmit;
259 laCallback.onError = OnLightError;
260 laCallback.onSessionKeyReturned = OnLightSessionKeyReturned;
261 laCallback.onFinish = OnLightFinish;
262 laCallback.onRequest = OnLightAuthRequest;
263
264 Uint8Buff returnKeyBuff = { 0 };
265 ret = ComputeHkdfKeyClient(TEST_OS_ACCOUNT_ID, out, returnRandom.data,
266 SERVICE_ID, &returnKeyBuff);
267 EXPECT_NE(ret, HC_SUCCESS);
268 ret = ComputeHkdfKeyServer(TEST_OS_ACCOUNT_ID, out, returnRandom.data,
269 SERVICE_ID, &returnKeyBuff);
270 EXPECT_NE(ret, HC_SUCCESS);
271 HcFree(returnKeyBuff.val);
272 DestroyDataBuff(&returnRandom);
273
274 ret = LightAuthOnFinish(TEST_REQ_ID, out, &laCallback);
275 EXPECT_EQ(ret, HC_SUCCESS);
276
277 ret = LightAuthOnTransmit(TEST_REQ_ID, out, &laCallback);
278 EXPECT_EQ(ret, HC_SUCCESS);
279 FreeJson(msg);
280 FreeJson(out);
281
282 int32_t testMsgLen = HcStrlen(TEST_LIGHT_MSG) + 1;
283 DataBuff testInMsg = {(uint8_t *)TEST_LIGHT_MSG, testMsgLen};
284 ret = ProcessLightAccountAuth(TEST_OS_ACCOUNT_ID, TEST_REQ_ID, &testInMsg, &laCallback);
285 EXPECT_NE(ret, HC_SUCCESS);
286 ret = ProcessLightAccountAuth(TEST_OS_ACCOUNT_ID, TEST_REQ_ID_0, &testInMsg, &laCallback);
287 EXPECT_NE(ret, HC_SUCCESS);
288 }
289
290 }