gfwleak/tango-maat
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[BUGFIX]fix keywords max length 1024

Browse Source
This commit is contained in:
liuwentan
2023-08-11 17:06:22 +08:00
parent d030e5a452
commit 8be8f33150
11 changed files with 47 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/inc_internal/maat_limits.h
View File

@@ -16,12 +16,9 @@ extern "C"
{ {
#endif #endif
#define MAX_KEYWORDS_STR 1024 #define MAX_KEYWORDS_STR_LEN 1024
#define MAX_MAAT_STAT_NUM 64 #define MAX_MAAT_STAT_NUM 64
#define MAX_NAME_STR_LEN 64 #define MAX_NAME_STR_LEN 64
#define MAX_INSTANCE_NAME_LEN 15 #define MAX_INSTANCE_NAME_LEN 15
#ifdef __cplusplus #ifdef __cplusplus

6
src/inc_internal/maat_rule.h
View File

@@ -40,7 +40,7 @@ extern "C"
#define DISTRICT_ANY -1 #define DISTRICT_ANY -1
#define DISTRICT_UNKNOWN -2 #define DISTRICT_UNKNOWN -2
#define MAX_DISTRICT_STR 128 #define MAX_DISTRICT_STR_LEN 128
#define INVALID_VERSION -1 #define INVALID_VERSION -1
#define mr_region_id_var "SEQUENCE_REGION" #define mr_region_id_var "SEQUENCE_REGION"
@@ -109,8 +109,8 @@ struct source_redis_ctx {
struct maat_options { struct maat_options {
char inst_name[MAX_INSTANCE_NAME_LEN + 1]; char inst_name[MAX_INSTANCE_NAME_LEN + 1];
char foreign_cont_dir[NAME_MAX]; char foreign_cont_dir[NAME_MAX];
char decrypt_algo[MAX_KEYWORDS_STR]; char decrypt_algo[MAX_KEYWORDS_STR_LEN];
char decrypt_key[MAX_KEYWORDS_STR]; char decrypt_key[MAX_KEYWORDS_STR_LEN];
char log_path[PATH_MAX]; char log_path[PATH_MAX];
int log_level; int log_level;
char stat_file[NAME_MAX]; char stat_file[NAME_MAX];

6
src/maat_compile.c
View File

@@ -284,8 +284,8 @@ compile_item_new(const char *table_line, struct compile_schema *schema,
compile_item->ref_schema = schema; compile_item->ref_schema = schema;
compile_item->ex_data = ALLOC(void *, 1); compile_item->ex_data = ALLOC(void *, 1);
memcpy(compile_item->table_name, table_name, sizeof(compile_item->table_name)); memcpy(compile_item->table_name, table_name, sizeof(compile_item->table_name));
compile_item->table_line_len = strlen(table_line) + 1; compile_item->table_line_len = strlen(table_line);
compile_item->table_line = ALLOC(char, compile_item->table_line_len); compile_item->table_line = ALLOC(char, compile_item->table_line_len + 1);
memcpy(compile_item->table_line, table_line, compile_item->table_line_len); memcpy(compile_item->table_line, table_line, compile_item->table_line_len);
if (1 == schema->set_flag) { if (1 == schema->set_flag) {
@@ -1154,7 +1154,7 @@ static struct compile_item *compile_item_clone(struct compile_item *item)
new_item->ex_data = ALLOC(void *, 1); new_item->ex_data = ALLOC(void *, 1);
memcpy(new_item->table_name, item->table_name, sizeof(new_item->table_name)); memcpy(new_item->table_name, item->table_name, sizeof(new_item->table_name));
new_item->table_line_len = item->table_line_len; new_item->table_line_len = item->table_line_len;
new_item->table_line = ALLOC(char, new_item->table_line_len); new_item->table_line = ALLOC(char, new_item->table_line_len + 1);
memcpy(new_item->table_line, item->table_line, new_item->table_line_len); memcpy(new_item->table_line, item->table_line, new_item->table_line_len);
if (1 == item->ref_schema->set_flag) { if (1 == item->ref_schema->set_flag) {

8
src/maat_ex_data.c
View File

@@ -93,11 +93,11 @@ void ex_data_runtime_cache_row_put(struct ex_data_runtime *ex_data_rt, const cha
return; return;
} }
size_t len = strlen(row) + 1; size_t row_len = strlen(row);
char* row_copy = ALLOC(char, len); char *row_copy = ALLOC(char, row_len + 1);
memcpy(row_copy, row, len); memcpy(row_copy, row, row_len);
ex_data_rt->cache_size += len; ex_data_rt->cache_size += row_len;
utarray_push_back(ex_data_rt->cache_rows, &row_copy); utarray_push_back(ex_data_rt->cache_rows, &row_copy);
ex_data_rt->cache_row_num++; ex_data_rt->cache_row_num++;
} }

17
src/maat_expr.c
View File

@@ -58,7 +58,7 @@ enum match_method {
struct expr_item { struct expr_item {
long long item_id; long long item_id;
long long group_id; long long group_id;
char keywords[MAX_KEYWORDS_STR]; char keywords[MAX_KEYWORDS_STR_LEN + 1];
enum expr_type expr_type; enum expr_type expr_type;
enum expr_match_mode match_mode; enum expr_match_mode match_mode;
int is_hexbin; int is_hexbin;
@@ -211,7 +211,7 @@ expr_item_new(struct expr_schema *expr_schema, const char *table_name,
goto error; goto error;
} }
if (column_len >= MAX_KEYWORDS_STR) { if (column_len > MAX_KEYWORDS_STR_LEN) {
log_error(expr_rt->logger, MODULE_EXPR, log_error(expr_rt->logger, MODULE_EXPR,
"[%s:%d] expr table:<%s> keywords length too long in line:%s", "[%s:%d] expr table:<%s> keywords length too long in line:%s",
__FUNCTION__, __LINE__, table_name, line); __FUNCTION__, __LINE__, table_name, line);
@@ -252,14 +252,15 @@ expr_item_new(struct expr_schema *expr_schema, const char *table_name,
goto error; goto error;
} }
if (column_len >= MAX_DISTRICT_STR) { if (column_len > MAX_DISTRICT_STR_LEN) {
log_error(expr_rt->logger, MODULE_EXPR, log_error(expr_rt->logger, MODULE_EXPR,
"[%s:%d] expr table:<%s> district length exceed maxium:%d in line:%s", "[%s:%d] expr table:<%s> district length exceed maximum:%d"
__FUNCTION__, __LINE__, table_name, MAX_DISTRICT_STR, line); " in line:%s", __FUNCTION__, __LINE__, table_name,
MAX_DISTRICT_STR_LEN, line);
goto error; goto error;
} }
char district[MAX_DISTRICT_STR] = {0}; char district[MAX_DISTRICT_STR_LEN + 1] = {0};
memcpy(district, (line + column_offset), column_len); memcpy(district, (line + column_offset), column_len);
assert(strlen(district) > 0); assert(strlen(district) > 0);
str_unescape(district); str_unescape(district);
@@ -722,8 +723,8 @@ static int expr_item_to_expr_rule(struct expr_item *expr_item,
if (TRUE == expr_item->is_hexbin && if (TRUE == expr_item->is_hexbin &&
expr_rule->patterns[i].type != EXPR_PATTERN_TYPE_REG) { expr_rule->patterns[i].type != EXPR_PATTERN_TYPE_REG) {
region_str_len = strlen(sub_key_array[i]) * 8 + 1; region_str_len = strlen(sub_key_array[i]) * 8;
region_string = ALLOC(char, region_str_len); region_string = ALLOC(char, region_str_len + 1);
region_str_len = hex2bin(sub_key_array[i], strlen(sub_key_array[i]), region_str_len = hex2bin(sub_key_array[i], strlen(sub_key_array[i]),
region_string, region_str_len); region_string, region_str_len);
} }

8
src/maat_flag.c
View File

@@ -333,15 +333,15 @@ flag_item_new(struct flag_schema *schema, const char *table_name,
goto error; goto error;
} }
if (column_len >= MAX_DISTRICT_STR) { if (column_len > MAX_DISTRICT_STR_LEN) {
log_error(flag_rt->logger, MODULE_FLAG, log_error(flag_rt->logger, MODULE_FLAG,
"[%s:%d] flag_plus table:<%s> district length exceed " "[%s:%d] flag_plus table:<%s> district length exceed "
"maxium:%d in line:%s", __FUNCTION__, __LINE__, table_name, "maximum:%d in line:%s", __FUNCTION__, __LINE__,
MAX_DISTRICT_STR, line); table_name, MAX_DISTRICT_STR_LEN, line);
goto error; goto error;
} }
char district[MAX_DISTRICT_STR] = {0}; char district[MAX_DISTRICT_STR_LEN + 1] = {0};
memcpy(district, (line + column_offset), column_len); memcpy(district, (line + column_offset), column_len);
assert(strlen(district) > 0); assert(strlen(district) > 0);
str_unescape(district); str_unescape(district);

8
src/maat_interval.c
View File

@@ -308,15 +308,15 @@ interval_item_new(struct interval_schema *schema, const char *table_name,
goto error; goto error;
} }
if (column_len >= MAX_DISTRICT_STR) { if (column_len > MAX_DISTRICT_STR_LEN) {
log_error(interval_rt->logger, MODULE_INTERVAL, log_error(interval_rt->logger, MODULE_INTERVAL,
"[%s:%d] interval_plus table:<%s> district length exceed " "[%s:%d] interval_plus table:<%s> district length exceed "
"maxium:%d in line:%s", __FUNCTION__, __LINE__, table_name, "maximum:%d in line:%s", __FUNCTION__, __LINE__, table_name,
MAX_DISTRICT_STR, line); MAX_DISTRICT_STR_LEN, line);
goto error; goto error;
} }
char district[MAX_DISTRICT_STR] = {0}; char district[MAX_DISTRICT_STR_LEN + 1] = {0};
memcpy(district, (line + column_offset), column_len); memcpy(district, (line + column_offset), column_len);
assert(strlen(district) > 0); assert(strlen(district) > 0);
str_unescape(district); str_unescape(district);

10
src/maat_plugin.c
View File

@@ -440,6 +440,14 @@ static int plugin_table_line_get_key(struct plugin_schema *schema,
return -1; return -1;
} }
if (key_len > MAX_KEYWORDS_STR_LEN) {
log_error(logger, MODULE_PLUGIN,
"[%s:%d] plugin table:<%s> key(column seq:%d) length exceed maxium:%d"
" in table_line:%s", __FUNCTION__, __LINE__, table_name,
schema->key_column, MAX_KEYWORDS_STR_LEN, line);
return -1;
}
const char *common_key = line + key_offset; const char *common_key = line + key_offset;
if (schema->key_type == PLUGIN_KEY_TYPE_POINTER) { if (schema->key_type == PLUGIN_KEY_TYPE_POINTER) {
memcpy(dst_key, common_key, key_len); memcpy(dst_key, common_key, key_len);
@@ -543,7 +551,7 @@ int plugin_runtime_update(void *plugin_runtime, void *plugin_schema,
return -1; return -1;
} }
char key[MAX_KEYWORDS_STR] = {0}; char key[MAX_KEYWORDS_STR_LEN + 1] = {0};
size_t key_len = 0; size_t key_len = 0;
ret = plugin_table_line_get_key(schema, table_name, line, key, &key_len, ret = plugin_table_line_get_key(schema, table_name, line, key, &key_len,
plugin_rt->logger); plugin_rt->logger);

10
src/maat_redis_monitor.c
View File

@@ -139,7 +139,7 @@ static void _get_foregin_keys(struct serial_rule *p_rule, int *foreign_columns,
__FUNCTION__, __LINE__, p_rule->table_name, p_rule->rule_id, p_foreign); __FUNCTION__, __LINE__, p_rule->table_name, p_rule->rule_id, p_foreign);
} }
p_rule->f_keys[p_rule->n_foreign].key = ALLOC(char, foreign_key_size+1); p_rule->f_keys[p_rule->n_foreign].key = ALLOC(char, foreign_key_size + 1);
memcpy(p_rule->f_keys[p_rule->n_foreign].key, p_foreign, foreign_key_size); memcpy(p_rule->f_keys[p_rule->n_foreign].key, p_foreign, foreign_key_size);
p_rule->f_keys[p_rule->n_foreign].filename = get_foreign_cont_filename(p_rule->table_name, p_rule->f_keys[p_rule->n_foreign].filename = get_foreign_cont_filename(p_rule->table_name,
p_rule->rule_id, p_rule->rule_id,
@@ -515,14 +515,14 @@ static struct serial_rule *serial_rule_clone(const struct serial_rule *s_rule)
new_rule->timeout = s_rule->timeout; new_rule->timeout = s_rule->timeout;
memcpy(new_rule->table_name, s_rule->table_name, strlen(s_rule->table_name)); memcpy(new_rule->table_name, s_rule->table_name, strlen(s_rule->table_name));
new_rule->n_foreign = s_rule->n_foreign; new_rule->n_foreign = s_rule->n_foreign;
new_rule->table_line = ALLOC(char, strlen(s_rule->table_line)); new_rule->table_line = ALLOC(char, strlen(s_rule->table_line) + 1);
memcpy(new_rule->table_line, s_rule->table_line, strlen(s_rule->table_line)); memcpy(new_rule->table_line, s_rule->table_line, strlen(s_rule->table_line));
new_rule->f_keys = ALLOC(struct foreign_key, new_rule->n_foreign); new_rule->f_keys = ALLOC(struct foreign_key, new_rule->n_foreign);
for (int j = 0; j < new_rule->n_foreign; j++) { for (int j = 0; j < new_rule->n_foreign; j++) {
new_rule->f_keys[j].key = ALLOC(char, s_rule->f_keys[j].key_len); new_rule->f_keys[j].key = ALLOC(char, s_rule->f_keys[j].key_len + 1);
memcpy(new_rule->f_keys[j].key, s_rule->f_keys[j].key, s_rule->f_keys[j].key_len); memcpy(new_rule->f_keys[j].key, s_rule->f_keys[j].key, s_rule->f_keys[j].key_len);
new_rule->f_keys[j].filename = ALLOC(char, strlen(s_rule->f_keys[j].filename)); new_rule->f_keys[j].filename = ALLOC(char, strlen(s_rule->f_keys[j].filename) + 1);
memcpy(new_rule->f_keys[j].filename, s_rule->f_keys[j].filename, memcpy(new_rule->f_keys[j].filename, s_rule->f_keys[j].filename,
strlen(s_rule->f_keys[j].filename)); strlen(s_rule->f_keys[j].filename));
} }
@@ -945,7 +945,7 @@ void maat_rewrite_table_line_with_foreign(struct serial_rule *s_rule)
fn_size += strlen(s_rule->f_keys[i].filename); fn_size += strlen(s_rule->f_keys[i].filename);
} }
char *rewrite_line = ALLOC(char, strlen(s_rule->table_line) + fn_size); char *rewrite_line = ALLOC(char, strlen(s_rule->table_line) + fn_size + 1);
char *pos_rewrite_line = rewrite_line; char *pos_rewrite_line = rewrite_line;
const char *pos_origin_line = s_rule->table_line; const char *pos_origin_line = s_rule->table_line;

4
test/expr_matcher_gtest.cpp
View File

@@ -171,8 +171,8 @@ int parse_config_file(const char *filename, struct expr_rule exprs[], size_t *n_
exprs[i].patterns[j].pat = ALLOC(char, strlen(item->valuestring) + 1); exprs[i].patterns[j].pat = ALLOC(char, strlen(item->valuestring) + 1);
if (is_hexbin == 1) { if (is_hexbin == 1) {
size_t pat_str_len = strlen(item->valuestring) + 1; size_t pat_str_len = strlen(item->valuestring);
char *pat_str = ALLOC(char, pat_str_len); char *pat_str = ALLOC(char, pat_str_len + 1);
pat_str_len = hex2bin(item->valuestring, strlen(item->valuestring), pat_str_len = hex2bin(item->valuestring, strlen(item->valuestring),
pat_str, pat_str_len); pat_str, pat_str_len);

6
test/maat_framework_gtest.cpp
View File

@@ -3875,7 +3875,7 @@ void bool_plugin_ex_new_cb(const char *table_name, int table_id, const char *key
ret = get_column_pos(table_line, 3, &column_offset, &column_len); ret = get_column_pos(table_line, 3, &column_offset, &column_len);
EXPECT_EQ(ret, 0); EXPECT_EQ(ret, 0);
ud->name = ALLOC(char, column_len+1); ud->name = ALLOC(char, column_len + 1);
memcpy(ud->name, table_line+column_offset, column_len); memcpy(ud->name, table_line+column_offset, column_len);
ud->name_len = column_len + 1; ud->name_len = column_len + 1;
@@ -4606,7 +4606,7 @@ TEST_F(MaatFileTest, StreamFiles) {
ASSERT_TRUE(ret == 0); ASSERT_TRUE(ret == 0);
file_size = file_info.st_size; file_size = file_info.st_size;
char *buff = ALLOC(char, file_size); char *buff = ALLOC(char, file_size + 1);
FILE *fp = fopen(file_path, "rb"); FILE *fp = fopen(file_path, "rb");
if (fp == NULL) { if (fp == NULL) {
printf("fopen %s error.\n", file_path); printf("fopen %s error.\n", file_path);
@@ -5655,7 +5655,7 @@ void prepare_file_to_set(const char* filename, char** file_buff, size_t *file_si
ASSERT_FALSE(fp == NULL); ASSERT_FALSE(fp == NULL);
*file_size = file_info.st_size; *file_size = file_info.st_size;
*file_buff = ALLOC(char, *file_size); *file_buff = ALLOC(char, *file_size + 1);
ret = fread(*file_buff, 1, *file_size, fp); ret = fread(*file_buff, 1, *file_size, fp);
fclose(fp); fclose(fp);