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
#define MAX_KEYWORDS_STR 1024
#define MAX_KEYWORDS_STR_LEN 1024
#define MAX_MAAT_STAT_NUM 64
#define MAX_NAME_STR_LEN 64
#define MAX_INSTANCE_NAME_LEN 15
#ifdef __cplusplus

6
src/inc_internal/maat_rule.h
View File

@@ -40,7 +40,7 @@ extern "C"
#define DISTRICT_ANY -1
#define DISTRICT_UNKNOWN -2
#define MAX_DISTRICT_STR 128
#define MAX_DISTRICT_STR_LEN 128
#define INVALID_VERSION -1
#define mr_region_id_var "SEQUENCE_REGION"
@@ -109,8 +109,8 @@ struct source_redis_ctx {
struct maat_options {
char inst_name[MAX_INSTANCE_NAME_LEN + 1];
char foreign_cont_dir[NAME_MAX];
char decrypt_algo[MAX_KEYWORDS_STR];
char decrypt_key[MAX_KEYWORDS_STR];
char decrypt_algo[MAX_KEYWORDS_STR_LEN];
char decrypt_key[MAX_KEYWORDS_STR_LEN];
char log_path[PATH_MAX];
int log_level;
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->ex_data = ALLOC(void *, 1);
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 = ALLOC(char, compile_item->table_line_len);
compile_item->table_line_len = strlen(table_line);
compile_item->table_line = ALLOC(char, compile_item->table_line_len + 1);
memcpy(compile_item->table_line, table_line, compile_item->table_line_len);
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);
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 = 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);
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;
}
size_t len = strlen(row) + 1;
char* row_copy = ALLOC(char, len);
size_t row_len = strlen(row);
char *row_copy = ALLOC(char, row_len + 1);
memcpy(row_copy, row, len);
ex_data_rt->cache_size += len;
memcpy(row_copy, row, row_len);
ex_data_rt->cache_size += row_len;
utarray_push_back(ex_data_rt->cache_rows, &row_copy);
ex_data_rt->cache_row_num++;
}

17
src/maat_expr.c
View File

@@ -58,7 +58,7 @@ enum match_method {
struct expr_item {
long long item_id;
long long group_id;
char keywords[MAX_KEYWORDS_STR];
char keywords[MAX_KEYWORDS_STR_LEN + 1];
enum expr_type expr_type;
enum expr_match_mode match_mode;
int is_hexbin;
@@ -211,7 +211,7 @@ expr_item_new(struct expr_schema *expr_schema, const char *table_name,
goto error;
}
if (column_len >= MAX_KEYWORDS_STR) {
if (column_len > MAX_KEYWORDS_STR_LEN) {
log_error(expr_rt->logger, MODULE_EXPR,
"[%s:%d] expr table:<%s> keywords length too long in line:%s",
__FUNCTION__, __LINE__, table_name, line);
@@ -252,14 +252,15 @@ expr_item_new(struct expr_schema *expr_schema, const char *table_name,
goto error;
}
if (column_len >= MAX_DISTRICT_STR) {
if (column_len > MAX_DISTRICT_STR_LEN) {
log_error(expr_rt->logger, MODULE_EXPR,
"[%s:%d] expr table:<%s> district length exceed maxium:%d in line:%s",
__FUNCTION__, __LINE__, table_name, MAX_DISTRICT_STR, line);
"[%s:%d] expr table:<%s> district length exceed maximum:%d"
" in line:%s", __FUNCTION__, __LINE__, table_name,
MAX_DISTRICT_STR_LEN, line);
goto error;
}
char district[MAX_DISTRICT_STR] = {0};
char district[MAX_DISTRICT_STR_LEN + 1] = {0};
memcpy(district, (line + column_offset), column_len);
assert(strlen(district) > 0);
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 &&
expr_rule->patterns[i].type != EXPR_PATTERN_TYPE_REG) {
region_str_len = strlen(sub_key_array[i]) * 8 + 1;
region_string = ALLOC(char, region_str_len);
region_str_len = strlen(sub_key_array[i]) * 8;
region_string = ALLOC(char, region_str_len + 1);
region_str_len = hex2bin(sub_key_array[i], strlen(sub_key_array[i]),
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;
}
if (column_len >= MAX_DISTRICT_STR) {
if (column_len > MAX_DISTRICT_STR_LEN) {
log_error(flag_rt->logger, MODULE_FLAG,
"[%s:%d] flag_plus table:<%s> district length exceed "
"maxium:%d in line:%s", __FUNCTION__, __LINE__, table_name,
MAX_DISTRICT_STR, line);
"maximum:%d in line:%s", __FUNCTION__, __LINE__,
table_name, MAX_DISTRICT_STR_LEN, line);
goto error;
}
char district[MAX_DISTRICT_STR] = {0};
char district[MAX_DISTRICT_STR_LEN + 1] = {0};
memcpy(district, (line + column_offset), column_len);
assert(strlen(district) > 0);
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;
}
if (column_len >= MAX_DISTRICT_STR) {
if (column_len > MAX_DISTRICT_STR_LEN) {
log_error(interval_rt->logger, MODULE_INTERVAL,
"[%s:%d] interval_plus table:<%s> district length exceed "
"maxium:%d in line:%s", __FUNCTION__, __LINE__, table_name,
MAX_DISTRICT_STR, line);
"maximum:%d in line:%s", __FUNCTION__, __LINE__, table_name,
MAX_DISTRICT_STR_LEN, line);
goto error;
}
char district[MAX_DISTRICT_STR] = {0};
char district[MAX_DISTRICT_STR_LEN + 1] = {0};
memcpy(district, (line + column_offset), column_len);
assert(strlen(district) > 0);
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;
}
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;
if (schema->key_type == PLUGIN_KEY_TYPE_POINTER) {
memcpy(dst_key, common_key, key_len);
@@ -543,7 +551,7 @@ int plugin_runtime_update(void *plugin_runtime, void *plugin_schema,
return -1;
}
char key[MAX_KEYWORDS_STR] = {0};
char key[MAX_KEYWORDS_STR_LEN + 1] = {0};
size_t key_len = 0;
ret = plugin_table_line_get_key(schema, table_name, line, key, &key_len,
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);
}
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);
p_rule->f_keys[p_rule->n_foreign].filename = get_foreign_cont_filename(p_rule->table_name,
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;
memcpy(new_rule->table_name, s_rule->table_name, strlen(s_rule->table_name));
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));
new_rule->f_keys = ALLOC(struct foreign_key, new_rule->n_foreign);
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);
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,
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);
}
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;
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);
if (is_hexbin == 1) {
size_t pat_str_len = strlen(item->valuestring) + 1;
char *pat_str = ALLOC(char, pat_str_len);
size_t pat_str_len = strlen(item->valuestring);
char *pat_str = ALLOC(char, pat_str_len + 1);
pat_str_len = hex2bin(item->valuestring, strlen(item->valuestring),
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);
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);
ud->name_len = column_len + 1;
@@ -4606,7 +4606,7 @@ TEST_F(MaatFileTest, StreamFiles) {
ASSERT_TRUE(ret == 0);
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");
if (fp == NULL) {
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);
*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);
fclose(fp);