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 "auth_common.h"
17
18 #include <securec.h>
19 #include <sys/time.h>
20
21 #include "softbus_base_listener.h"
22 #include "softbus_errcode.h"
23 #include "softbus_feature_config.h"
24 #include "softbus_log.h"
25
26 #define DEFAULT_AUTH_ABILITY_COLLECTION 0
27 #define AUTH_SUPPORT_SERVER_SIDE_MASK 0x01
28 #define INTERVAL_VALUE 2
29 #define OFFSET_BITS 24
30 #define INT_MAX_VALUE 0xFFFFFEL
31 #define LOW_24_BITS 0xFFFFFFL
32 static uint64_t g_uniqueId = 0;
33 static uint32_t g_authAbility = 0;
34
GetSeq(AuthSideFlag flag)35 int64_t GetSeq(AuthSideFlag flag)
36 {
37 static uint64_t integer = 0;
38 if (integer == INT_MAX_VALUE) {
39 integer = 0;
40 }
41 integer += INTERVAL_VALUE;
42 uint64_t temp = integer;
43 if (flag == SERVER_SIDE_FLAG) {
44 temp += 1;
45 }
46 temp = ((g_uniqueId << OFFSET_BITS) | (temp & LOW_24_BITS));
47 int64_t seq = 0;
48 if (memcpy_s(&seq, sizeof(int64_t), &temp, sizeof(uint64_t)) != EOK) {
49 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "memcpy_s seq error");
50 }
51 return seq;
52 }
53
AuthGetNextConnectionId(void)54 uint16_t AuthGetNextConnectionId(void)
55 {
56 static uint16_t authConnId = 0;
57 return ++authConnId;
58 }
59
AuthGetSideByRemoteSeq(int64_t seq)60 AuthSideFlag AuthGetSideByRemoteSeq(int64_t seq)
61 {
62 /* even odd check */
63 return (seq % 2) == 0 ? SERVER_SIDE_FLAG : CLIENT_SIDE_FLAG;
64 }
65
AuthGetAbility(void)66 void AuthGetAbility(void)
67 {
68 if (SoftbusGetConfig(SOFTBUS_INT_AUTH_ABILITY_COLLECTION,
69 (unsigned char*)&g_authAbility, sizeof(g_authAbility)) != SOFTBUS_OK) {
70 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "Cannot get auth ability from config file");
71 g_authAbility = DEFAULT_AUTH_ABILITY_COLLECTION;
72 }
73 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "auth ability is %u", g_authAbility);
74 }
75
AuthIsSupportServerSide(void)76 bool AuthIsSupportServerSide(void)
77 {
78 return (g_authAbility & AUTH_SUPPORT_SERVER_SIDE_MASK) ? true : false;
79 }
80
UniqueIdInit(void)81 void UniqueIdInit(void)
82 {
83 struct timeval time = {0};
84 gettimeofday(&time, NULL);
85 g_uniqueId = (uint64_t)(time.tv_usec);
86 }
87
AuthGetDeviceKey(char * key,uint32_t size,uint32_t * len,const ConnectOption * option)88 int32_t AuthGetDeviceKey(char *key, uint32_t size, uint32_t *len, const ConnectOption *option)
89 {
90 if (key == NULL || len == NULL || option == NULL) {
91 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "invalid parameter");
92 return SOFTBUS_ERR;
93 }
94 switch (option->type) {
95 case CONNECT_BR:
96 if (strcpy_s(key, size, option->info.brOption.brMac) != EOK) {
97 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "strcpy_s failed");
98 return SOFTBUS_ERR;
99 }
100 *len = BT_MAC_LEN;
101 break;
102 case CONNECT_BLE:
103 if (strcpy_s(key, size, option->info.bleOption.bleMac) != EOK) {
104 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "strcpy_s failed");
105 return SOFTBUS_ERR;
106 }
107 *len = BT_MAC_LEN;
108 break;
109 case CONNECT_TCP:
110 if (strcpy_s(key, size, option->info.ipOption.ip) != EOK) {
111 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "strcpy_s failed");
112 return SOFTBUS_ERR;
113 }
114 *len = IP_LEN;
115 break;
116 default:
117 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "unknown type");
118 return SOFTBUS_ERR;
119 }
120 return SOFTBUS_OK;
121 }
122
AuthConvertConnInfo(ConnectOption * option,const ConnectionInfo * connInfo)123 int32_t AuthConvertConnInfo(ConnectOption *option, const ConnectionInfo *connInfo)
124 {
125 if (option == NULL || connInfo == NULL) {
126 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "invalid parameter");
127 return SOFTBUS_ERR;
128 }
129 option->type = connInfo->type;
130 switch (connInfo->type) {
131 case CONNECT_BR: {
132 if (strcpy_s(option->info.brOption.brMac, BT_MAC_LEN, connInfo->info.brInfo.brMac) != EOK) {
133 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "strcpy_s failed");
134 return SOFTBUS_ERR;
135 }
136 break;
137 }
138 case CONNECT_BLE:
139 if (strcpy_s(option->info.bleOption.bleMac, BT_MAC_LEN, connInfo->info.bleInfo.bleMac) != EOK ||
140 memcpy_s(option->info.bleOption.deviceIdHash, UDID_HASH_LEN,
141 connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN) != EOK) {
142 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "strcpy_s failed");
143 return SOFTBUS_ERR;
144 }
145 break;
146 case CONNECT_TCP: {
147 if (strcpy_s(option->info.ipOption.ip, IP_LEN, connInfo->info.ipInfo.ip) != EOK) {
148 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "strcpy_s failed");
149 return SOFTBUS_ERR;
150 }
151 option->info.ipOption.port = connInfo->info.ipInfo.port;
152 break;
153 }
154 default: {
155 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "unknown type");
156 return SOFTBUS_ERR;
157 }
158 }
159 return SOFTBUS_OK;
160 }
161
ConvertAuthConnInfoToOption(const AuthConnInfo * info,ConnectOption * option)162 int32_t ConvertAuthConnInfoToOption(const AuthConnInfo *info, ConnectOption *option)
163 {
164 if (info == NULL || option == NULL) {
165 return SOFTBUS_INVALID_PARAM;
166 }
167 switch (info->type) {
168 case AUTH_LINK_TYPE_WIFI:
169 option->type = CONNECT_TCP;
170 if (strcpy_s(option->info.ipOption.ip, sizeof(option->info.ipOption.ip), info->info.ipInfo.ip) != EOK) {
171 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "copy ip failed.");
172 return SOFTBUS_MEM_ERR;
173 }
174 option->info.ipOption.port = info->info.ipInfo.port;
175 break;
176 case AUTH_LINK_TYPE_BR:
177 option->type = CONNECT_BR;
178 if (strcpy_s(option->info.brOption.brMac, sizeof(option->info.brOption.brMac),
179 info->info.brInfo.brMac) != EOK) {
180 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "copy brMac failed.");
181 return SOFTBUS_MEM_ERR;
182 }
183 break;
184 case AUTH_LINK_TYPE_BLE:
185 option->type = CONNECT_BLE;
186 if (strcpy_s(option->info.bleOption.bleMac, sizeof(option->info.bleOption.bleMac),
187 info->info.bleInfo.bleMac) != EOK) {
188 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "copy bleMac failed.");
189 return SOFTBUS_MEM_ERR;
190 }
191 break;
192 case AUTH_LINK_TYPE_P2P:
193 option->type = CONNECT_TCP;
194 if (strcpy_s(option->info.ipOption.ip, sizeof(option->info.ipOption.ip), info->info.ipInfo.ip) != EOK) {
195 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "copy ip failed.");
196 return SOFTBUS_MEM_ERR;
197 }
198 option->info.ipOption.port = info->info.ipInfo.port;
199 option->info.ipOption.moduleId = AUTH_P2P;
200 break;
201 default:
202 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "unsupport link type, type = %d.", info->type);
203 return SOFTBUS_INVALID_PARAM;
204 }
205 return SOFTBUS_OK;
206 }
207
ConvertOptionToAuthConnInfo(const ConnectOption * option,bool isAuthP2p,AuthConnInfo * info)208 int32_t ConvertOptionToAuthConnInfo(const ConnectOption *option, bool isAuthP2p, AuthConnInfo *info)
209 {
210 if (option == NULL || info == NULL) {
211 return SOFTBUS_INVALID_PARAM;
212 }
213 switch (option->type) {
214 case CONNECT_TCP:
215 info->type = isAuthP2p ? AUTH_LINK_TYPE_P2P : AUTH_LINK_TYPE_WIFI;
216 if (strcpy_s(info->info.ipInfo.ip, sizeof(info->info.ipInfo.ip), option->info.ipOption.ip) != EOK) {
217 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "copy ip failed.");
218 return SOFTBUS_MEM_ERR;
219 }
220 info->info.ipInfo.port = option->info.ipOption.port;
221 break;
222 case CONNECT_BR:
223 info->type = AUTH_LINK_TYPE_BR;
224 if (strcpy_s(info->info.brInfo.brMac, sizeof(info->info.brInfo.brMac),
225 option->info.brOption.brMac) != EOK) {
226 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "copy brMac failed.");
227 return SOFTBUS_MEM_ERR;
228 }
229 break;
230 case CONNECT_BLE:
231 info->type = AUTH_LINK_TYPE_BLE;
232 if (strcpy_s(info->info.bleInfo.bleMac, sizeof(info->info.bleInfo.bleMac),
233 option->info.bleOption.bleMac) != EOK) {
234 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "copy bleMac failed.");
235 return SOFTBUS_MEM_ERR;
236 }
237 break;
238 default:
239 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "unknown type, type = %d.", option->type);
240 return SOFTBUS_INVALID_PARAM;
241 }
242 return SOFTBUS_OK;
243 }
244
CompareConnectOption(const ConnectOption * option1,const ConnectOption * option2)245 bool CompareConnectOption(const ConnectOption *option1, const ConnectOption *option2)
246 {
247 if (option1 == NULL || option2 == NULL) {
248 return false;
249 }
250 switch (option1->type) {
251 case CONNECT_TCP:
252 if (option2->type == CONNECT_TCP &&
253 strcmp(option1->info.ipOption.ip, option2->info.ipOption.ip) == 0) {
254 return true;
255 }
256 break;
257 case CONNECT_BR:
258 if (option2->type == CONNECT_BR &&
259 strcmp(option1->info.brOption.brMac, option2->info.brOption.brMac) == 0) {
260 return true;
261 }
262 break;
263 case CONNECT_BLE:
264 if (option2->type == CONNECT_BLE &&
265 strcmp(option1->info.bleOption.bleMac, option2->info.bleOption.bleMac) == 0) {
266 return true;
267 }
268 break;
269 default:
270 break;
271 }
272 return false;
273 }