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 "softbus_log.h"
17
18 #include <regex.h>
19 #include <securec.h>
20 #include <string.h>
21
22 #include "softbus_adapter_mem.h"
23 #include "softbus_errcode.h"
24 #include "softbus_feature_config.h"
25 #include "softbus_utils.h"
26
27 #define LOG_NAME_MAX_LEN 5
28 #ifndef SOFTBUS_DEBUG
29 #define LOG_PRINT_MAX_LEN 256
30 #else
31 #define LOG_PRINT_MAX_LEN 512
32 #endif
33
34 // anonymize should mask more than half of the string
35 #define EXPECTED_ANONYMIZED_TIMES 2
36
37 #define PMATCH_SIZE 2
38 #define REG_ID_PATTERN "[0-9A-Za-z]{64}"
39 #define REG_IDT_PATTERN "\\\"[0-9A-Za-z]{32}\\\""
40 #define REG_IP_PATTERN "[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}"
41 #define REG_MAC_PATTERN "([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}"
42 #define REG_KEY_PATTERN "[0-9A-Za-z+-//]{43}="
43 #define REG_PATTERN_MAX_LEN 256
44 #define INLEN_MULTIPLE_FACTOR 2
45
46 #define PLAINTEXT_LEN_SHORT 1
47 #define PLAINTEXT_LEN_NORMAL 4
48 #define ANONYMIZE_LEN 6
49 #define SHORT_ID_LENGTH 20
50 #define SESSION_NAME_DEVICE_ID_LEN 96
51 #define SESSION_NAME_DEVICE_PATTERN "([0-9A-Z]{32}){1,3}"
52 #define CUST_NSTACKX_DFINDER_LOG 5
53
54 static int32_t g_logLevel;
55
56 typedef struct {
57 SoftBusLogModule mod;
58 char name[LOG_NAME_MAX_LEN];
59 } LogInfo;
60
61 typedef enum {
62 ANONYMIZE_NORMAL = 1,
63 ANONYMIZE_ENHANCE
64 } AnonymizeMode;
65
66 static LogInfo g_logInfo[SOFTBUS_LOG_MODULE_MAX] = {
67 {SOFTBUS_LOG_AUTH, "AUTH"},
68 {SOFTBUS_LOG_TRAN, "TRAN"},
69 {SOFTBUS_LOG_CONN, "CONN"},
70 {SOFTBUS_LOG_LNN, "LNN"},
71 {SOFTBUS_LOG_DISC, "DISC"},
72 {SOFTBUS_LOG_COMM, "COMM"},
73 };
74
NstackxLog(const char * moduleName,uint32_t nstackLevel,const char * format,...)75 void NstackxLog(const char *moduleName, uint32_t nstackLevel, const char *format, ...)
76 {
77 uint32_t ulPos;
78 uint32_t level = CUST_NSTACKX_DFINDER_LOG - nstackLevel;
79 char szStr[LOG_PRINT_MAX_LEN] = {0};
80 va_list arg;
81 int32_t ret;
82
83 if (moduleName == NULL || level >= SOFTBUS_LOG_LEVEL_MAX) {
84 HILOG_ERROR(SOFTBUS_HILOG_ID, "Nstackx log moduleName or level error");
85 return;
86 }
87
88 SoftbusGetConfig(SOFTBUS_INT_ADAPTER_LOG_LEVEL, (unsigned char *)&g_logLevel, sizeof(g_logLevel));
89 if ((int32_t)level < g_logLevel) {
90 return;
91 }
92
93 ret = sprintf_s(szStr, sizeof(szStr), "[%s]", moduleName);
94 if (ret < 0) {
95 HILOG_ERROR(SOFTBUS_HILOG_ID, "Nstackx log error");
96 return;
97 }
98 ulPos = strlen(szStr);
99 (void)memset_s(&arg, sizeof(va_list), 0, sizeof(va_list));
100 va_start(arg, format);
101 ret = vsprintf_s(&szStr[ulPos], sizeof(szStr) - ulPos, format, arg);
102 va_end(arg);
103 if (ret < 0) {
104 HILOG_WARN(SOFTBUS_HILOG_ID, "Nstackx log len error");
105 return;
106 }
107 SoftBusOutPrint(szStr, (SoftBusLogLevel)level);
108
109 return;
110 }
111
SoftBusLog(SoftBusLogModule module,SoftBusLogLevel level,const char * fmt,...)112 void SoftBusLog(SoftBusLogModule module, SoftBusLogLevel level, const char *fmt, ...)
113 {
114 uint32_t ulPos;
115 char szStr[LOG_PRINT_MAX_LEN] = {0};
116 va_list arg;
117 int32_t ret;
118
119 if (module >= SOFTBUS_LOG_MODULE_MAX || level >= SOFTBUS_LOG_LEVEL_MAX) {
120 HILOG_ERROR(SOFTBUS_HILOG_ID, "[COMM]softbus log type or module error");
121 return;
122 }
123
124 SoftbusGetConfig(SOFTBUS_INT_ADAPTER_LOG_LEVEL, (unsigned char *)&g_logLevel, sizeof(g_logLevel));
125 if ((int32_t)level < g_logLevel) {
126 return;
127 }
128
129 ret = sprintf_s(szStr, sizeof(szStr), "[%s]", g_logInfo[module].name);
130 if (ret < 0) {
131 HILOG_ERROR(SOFTBUS_HILOG_ID, "[COMM]softbus log error");
132 return;
133 }
134 ulPos = strlen(szStr);
135 (void)memset_s(&arg, sizeof(va_list), 0, sizeof(va_list));
136 va_start(arg, fmt);
137 ret = vsprintf_s(&szStr[ulPos], sizeof(szStr) - ulPos, fmt, arg);
138 va_end(arg);
139 if (ret < 0) {
140 HILOG_WARN(SOFTBUS_HILOG_ID, "[COMM]softbus log len error");
141 return;
142 }
143 SoftBusOutPrint(szStr, level);
144
145 return;
146 }
147
Anonymizes(const char * target,const uint8_t expectAnonymizedLength)148 const char *Anonymizes(const char *target, const uint8_t expectAnonymizedLength)
149 {
150 if (target == NULL) {
151 return "NULL";
152 }
153 if (expectAnonymizedLength == 0) {
154 return "BADLENGTH";
155 }
156 size_t targetLen = strlen(target);
157 if (targetLen / expectAnonymizedLength < EXPECTED_ANONYMIZED_TIMES) {
158 return "TOOSHORT";
159 }
160
161 return target + (targetLen - expectAnonymizedLength);
162 }
163
AnonymizeRegInit(regex_t * preg,const char * pattern)164 static int32_t AnonymizeRegInit(regex_t *preg, const char *pattern)
165 {
166 if (regcomp(preg, pattern, REG_EXTENDED) != 0) {
167 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "init anonymize reg: compile reg pattern fail");
168 return SOFTBUS_ERR;
169 }
170 return SOFTBUS_OK;
171 }
172
AnonymizeRegDeinit(regex_t * preg)173 static void AnonymizeRegDeinit(regex_t *preg)
174 {
175 regfree(preg);
176 }
177
AnonymizeStringProcess(char * str,size_t len,AnonymizeMode mode)178 static int32_t AnonymizeStringProcess(char *str, size_t len, AnonymizeMode mode)
179 {
180 if (len < ANONYMIZE_LEN || mode == ANONYMIZE_ENHANCE) {
181 if (strcpy_s(str, len, "******") != EOK) {
182 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize string: strncpy fail.");
183 return SOFTBUS_MEM_ERR;
184 }
185 } else {
186 uint32_t plaintextLen = len < SHORT_ID_LENGTH ? PLAINTEXT_LEN_SHORT : PLAINTEXT_LEN_NORMAL;
187 if (memset_s(str + plaintextLen, len - plaintextLen, '*', ANONYMIZE_LEN) != EOK) {
188 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize string: memset fail.");
189 return SOFTBUS_MEM_ERR;
190 }
191 uint32_t offset = plaintextLen + ANONYMIZE_LEN;
192 if (strncpy_s(str + offset, len - offset, str + len - plaintextLen, plaintextLen) != EOK) {
193 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize string: strncpy fail.");
194 return SOFTBUS_MEM_ERR;
195 }
196 }
197 return SOFTBUS_OK;
198 }
199
AnonymizeString(char ** output,const char * in,size_t inLen,const char * pattern,AnonymizeMode mode)200 static int32_t AnonymizeString(char **output, const char *in, size_t inLen, const char *pattern, AnonymizeMode mode)
201 {
202 if (in == NULL) {
203 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize string: in is null");
204 return SOFTBUS_INVALID_PARAM;
205 }
206
207 char *str = (char *)SoftBusCalloc(inLen + 1);
208 if (str == NULL) {
209 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize string: malloc fail.");
210 return SOFTBUS_MEM_ERR;
211 }
212 if (strcpy_s(str, inLen + 1, in) != EOK) {
213 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize string: strcpy fail.");
214 SoftBusFree(str);
215 return SOFTBUS_MEM_ERR;
216 }
217 regex_t preg;
218 if (AnonymizeRegInit(&preg, pattern) != SOFTBUS_OK) {
219 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize string: init reg failed.");
220 SoftBusFree(str);
221 return SOFTBUS_ERR;
222 }
223 regmatch_t pmatch[PMATCH_SIZE];
224 (void)memset_s(pmatch, sizeof(regmatch_t) * PMATCH_SIZE, 0, sizeof(regmatch_t) * PMATCH_SIZE);
225 char *outexec = str;
226 do {
227 if (regexec(&preg, outexec, PMATCH_SIZE, pmatch, 0) != 0) {
228 break;
229 }
230 regoff_t start = pmatch[0].rm_so;
231 regoff_t end = pmatch[0].rm_eo;
232 if (start != end) {
233 if (AnonymizeStringProcess(outexec + start, end - start, mode) != SOFTBUS_OK) {
234 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymizeStringProcess fail");
235 SoftBusFree(str);
236 AnonymizeRegDeinit(&preg);
237 return SOFTBUS_ERR;
238 }
239 int32_t offset = start + (int32_t)strlen(outexec + start);
240 char tmpStr[inLen + 1];
241 if (strcpy_s(tmpStr, inLen + 1, outexec + end) != EOK || strcat_s(str, inLen, tmpStr) != EOK) {
242 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize string: strcat fail.");
243 break;
244 }
245 outexec += offset;
246 }
247 } while (true);
248 *output = str;
249 AnonymizeRegDeinit(&preg);
250 return SOFTBUS_OK;
251 }
252
AnonyPacketPrintout(SoftBusLogModule module,const char * msg,const char * packet,size_t packetLen)253 void AnonyPacketPrintout(SoftBusLogModule module, const char *msg, const char *packet, size_t packetLen)
254 {
255 if (!GetSignalingMsgSwitch()) {
256 return;
257 }
258 if (msg == NULL) {
259 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize packet: msg is null.");
260 return;
261 }
262 if (packet == NULL || packetLen == 0) {
263 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize packet: packet is null.");
264 return;
265 }
266 if (packetLen > LOG_PRINT_MAX_LEN * INLEN_MULTIPLE_FACTOR) {
267 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize packet: packet is too long.");
268 return;
269 }
270
271 #ifdef __LITEOS_M__
272 SoftBusLog(module, SOFTBUS_LOG_INFO, "%s******", msg);
273 #else
274 char pattern[REG_PATTERN_MAX_LEN] = {0};
275 if (sprintf_s(pattern, REG_PATTERN_MAX_LEN, "%s|%s|%s|%s|%s",
276 REG_ID_PATTERN, REG_IDT_PATTERN, REG_IP_PATTERN, REG_MAC_PATTERN, REG_KEY_PATTERN) < 0) {
277 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anonymize packet: concatenate reg pattern fail");
278 return;
279 }
280 char *anonymizedOut = NULL;
281 int32_t ret = AnonymizeString(&anonymizedOut, packet, packetLen, pattern, ANONYMIZE_NORMAL);
282 if (ret == SOFTBUS_OK) {
283 SoftBusLog(module, SOFTBUS_LOG_INFO, "%s%s", msg, anonymizedOut);
284 SoftBusFree(anonymizedOut);
285 }
286 #endif
287 }
288
AnonyDevId(char ** outName,const char * inName)289 const char *AnonyDevId(char **outName, const char *inName)
290 {
291 if (inName == NULL) {
292 return "null";
293 }
294 if (strlen(inName) < SESSION_NAME_DEVICE_ID_LEN) {
295 return inName;
296 }
297 #ifdef __LITEOS_M__
298 return "******";
299 #else
300 if (AnonymizeString(outName, inName, strlen(inName), SESSION_NAME_DEVICE_PATTERN, ANONYMIZE_NORMAL) != SOFTBUS_OK) {
301 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "anony sessionname fail.");
302 return "******";
303 }
304 return *outName;
305 #endif
306 }
307