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

TSG-14928: 接收通知的ssl_intercept_info信息,填充到Proxy_intercept_event日志中发送; 接收SCE/SHAPER通知的日志信息

Browse Source
This commit is contained in:
杨玉波
2023-05-10 07:35:03 +00:00
committed by liuxueli
parent c5e959492d
commit ee0f57d6d3
15 changed files with 1666 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
src/tsg_bridge.cpp
View File

@@ -26,6 +26,66 @@ struct bridge_info
struct bridge_info g_tm_bridge_para[BRIDGE_TYPE_MAX];
void session_sce_log_update_free(const struct streaminfo *a_stream, int bridge_id, void *data)
{
if (data != NULL)
{
dictator_free(a_stream->threadnum, data);
data = NULL;
}
return;
}
void session_shaper_log_update_free(const struct streaminfo *a_stream, int bridge_id, void *data)
{
if (data != NULL)
{
dictator_free(a_stream->threadnum, data);
data = NULL;
}
return;
}
void session_proxy_log_update_free(const struct streaminfo *a_stream, int bridge_id, void *data)
{
struct proxy_log_update *proxy = (struct proxy_log_update *)data;
if (proxy != NULL)
{
if (proxy->ssl_downstream_version != NULL)
{
dictator_free(a_stream->threadnum, (void *)proxy->ssl_downstream_version);
proxy->ssl_downstream_version = NULL;
}
if (proxy->ssl_error != NULL)
{
dictator_free(a_stream->threadnum, (void *)proxy->ssl_error);
proxy->ssl_error = NULL;
}
if (proxy->ssl_passthrough_reason != NULL)
{
dictator_free(a_stream->threadnum, (void *)proxy->ssl_passthrough_reason);
proxy->ssl_passthrough_reason = NULL;
}
if (proxy->ssl_upstream_version != NULL)
{
dictator_free(a_stream->threadnum, (void *)proxy->ssl_upstream_version);
proxy->ssl_upstream_version = NULL;
}
dictator_free(a_stream->threadnum, (void *)proxy);
proxy = NULL;
}
data = NULL;
return;
}
void session_runtime_process_context_free(const struct streaminfo *a_stream, int bridge_id, void *data)
{
struct session_runtime_process_context *srt_process_context=(struct session_runtime_process_context *)data;
@@ -222,7 +282,7 @@ int srt_attribute_set_establish_latecy(const struct streaminfo *a_stream)
{
return 0;
}
struct session_runtime_attribute *srt_attribute=(struct session_runtime_attribute *)session_runtime_attribute_new(a_stream);
if(srt_attribute)
{
@@ -935,6 +995,42 @@ void *session_lua_user_defined_attribute_get(const struct streaminfo *a_stream)
return session_async_bridge_get_data(a_stream, g_tm_bridge_para[BRIDGE_TYPE_APP_LUA_RESULT].id);
}
void *session_log_update_data_get(const struct streaminfo *a_stream, enum TSG_SERVICE service)
{
switch (service)
{
case TSG_SERVICE_INTERCEPT:
return stream_bridge_async_data_get(a_stream, g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_PROXY].id);
case TSG_SERVICE_CHAINING:
return stream_bridge_async_data_get(a_stream, g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_SCE].id);
case TSG_SERVICE_SHAPING:
return stream_bridge_async_data_get(a_stream, g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_SHAPER].id);
default:
return NULL;
}
}
int session_log_update_data_put(const struct streaminfo *a_stream, enum TSG_SERVICE service, void *data)
{
switch (service)
{
case TSG_SERVICE_INTERCEPT:
return stream_bridge_async_data_put(a_stream, g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_PROXY].id, data);
case TSG_SERVICE_CHAINING:
return stream_bridge_async_data_put(a_stream, g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_SCE].id, data);
case TSG_SERVICE_SHAPING:
return stream_bridge_async_data_put(a_stream, g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_SHAPER].id, data);
default:
return 0;
}
}
int tsg_bridge_init(const char *conffile)
{
MESA_load_profile_string_def(conffile, "BRIDGE", "APP_IDENTIFY_RESULT_BRIDGE", g_tm_bridge_para[BRIDGE_TYPE_SYNC_APP_IDENTIFY_RESULT].name, MAX_BRIDGE_NAME_LEN, "APP_IDENTIFY_RESULT_BRIDGE");
@@ -984,6 +1080,15 @@ int tsg_bridge_init(const char *conffile)
MESA_load_profile_string_def(conffile, "BRIDGE", "SEGMENT_IDS_BRIDGE_NAME",g_tm_bridge_para[BRIDGE_TYPE_SEGMENT_IDS].name, MAX_BRIDGE_NAME_LEN, "SEGMENT_IDS");
g_tm_bridge_para[BRIDGE_TYPE_SEGMENT_IDS].free_cb=session_segment_id_free;
MESA_load_profile_string_def(conffile, "BRIDGE", "SCE_LOG_UPDATE_BRIDGE_NAME", g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_SCE].name, MAX_BRIDGE_NAME_LEN, "SCE_LOG_UPDATE");
g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_SCE].free_cb = session_sce_log_update_free;
MESA_load_profile_string_def(conffile, "BRIDGE", "SHAPER_LOG_UPDATE_BRIDGE_NAME", g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_SHAPER].name, MAX_BRIDGE_NAME_LEN, "SHAPER_LOG_UPDATE");
g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_SHAPER].free_cb = session_shaper_log_update_free;
MESA_load_profile_string_def(conffile, "BRIDGE", "PROXY_LOG_UPDATE_BRIDGE_NAME", g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_PROXY].name, MAX_BRIDGE_NAME_LEN, "PROXY_LOG_UPDATE");
g_tm_bridge_para[BRIDGE_TYPE_LOG_UPDATE_PROXY].free_cb = session_proxy_log_update_free;
for(int i=0; i<BRIDGE_TYPE_MAX; i++)
{
g_tm_bridge_para[i].id=stream_bridge_build(g_tm_bridge_para[i].name, "w");

30
src/tsg_bridge.h
View File

@@ -13,18 +13,18 @@
enum BRIDGE_TYPE
{
BRIDGE_TYPE_SEND_CONN_SKETCH_DATA=0,
BRIDGE_TYPE_SEND_CONN_SKETCH_DATA = 0,
BRIDGE_TYPE_RECV_CONN_SKETCH_DATA,
BRIDGE_TYPE_SYNC_APP_IDENTIFY_RESULT,
BRIDGE_TYPE_SYNC_SESSION_FLAGS,
BRIDGE_TYPE_SHAPING_RESULT, //sync and async
BRIDGE_TYPE_SESSION_PROCESS_CONTEXT, //async
BRIDGE_TYPE_SESSION_ACTION_CONTEXT, //async
BRIDGE_TYPE_GATHER_APP_RESULT, //async
BRIDGE_TYPE_SERVICE_CHAINING_RESULT, //async
BRIDGE_TYPE_SECURITY_RESULT, //async
BRIDGE_TYPE_SESSION_ATTRIBUTE, //async
BRIDGE_TYPE_MAC_LINKINFO, //async
BRIDGE_TYPE_SHAPING_RESULT, // sync and async
BRIDGE_TYPE_SESSION_PROCESS_CONTEXT, // async
BRIDGE_TYPE_SESSION_ACTION_CONTEXT, // async
BRIDGE_TYPE_GATHER_APP_RESULT, // async
BRIDGE_TYPE_SERVICE_CHAINING_RESULT, // async
BRIDGE_TYPE_SECURITY_RESULT, // async
BRIDGE_TYPE_SESSION_ATTRIBUTE, // async
BRIDGE_TYPE_MAC_LINKINFO, // async
BRIDGE_TYPE_NAT_C2S_LINKINFO,
BRIDGE_TYPE_NAT_S2C_LINKINFO,
BRIDGE_TYPE_APP_LUA_RESULT,
@@ -33,8 +33,12 @@ enum BRIDGE_TYPE
BRIDGE_TYPE_POLICY_ACTION_PARA_EXEC_RESULT,
BRIDGE_TYPE_ASYNC_SESSION_FLAGS,
BRIDGE_TYPE_APP_SIGNATURE_RESULT,
BRIDGE_TYPE_INTERCEPT_RESULT, //sync and async
BRIDGE_TYPE_SEGMENT_IDS, //async service_chaining or shping SID
BRIDGE_TYPE_INTERCEPT_RESULT, // sync and async
BRIDGE_TYPE_SEGMENT_IDS, // async service_chaining or shping SID
BRIDGE_TYPE_LOG_UPDATE_SCE,
BRIDGE_TYPE_LOG_UPDATE_SHAPER,
BRIDGE_TYPE_LOG_UPDATE_PROXY,
BRIDGE_TYPE_MAX
};
@@ -139,6 +143,10 @@ struct session_runtime_attribute
// init
int tsg_bridge_init(const char *conffile);
// tsg_parse_log_update
void *session_log_update_data_get(const struct streaminfo *a_stream, enum TSG_SERVICE service);
int session_log_update_data_put(const struct streaminfo *a_stream, enum TSG_SERVICE service, void *data);
//send log
void *session_mac_linkinfo_get(const struct streaminfo * a_stream);
void *session_conn_sketch_notify_data_get(const struct streaminfo * a_stream);

36
src/tsg_entry.cpp
View File

@@ -735,6 +735,30 @@ int session_app_gather_results_update_matched_app_id(const struct streaminfo *a_
return 1;
}
int session_state_control_packet(const struct streaminfo *a_stream, void *payload, unsigned int payload_len)
{
if(payload==NULL || payload_len==0)
{
return 0;
}
int is_ctrl_pkt=0;
const void *raw_pkt = get_rawpkt_from_streaminfo(a_stream);
int ret=get_opt_from_rawpkt(raw_pkt, RAW_PKT_GET_IS_CTRL_PKT, (void *)&is_ctrl_pkt);
if(ret<0 || is_ctrl_pkt==0)
{
return 0;
}
ret=tsg_parse_log_update_payload(a_stream, (const void *)payload, payload_len);
if(ret>=0)
{
return 1;
}
return 0;
}
int session_state_sync_in_opening_and_closing(const struct streaminfo *a_stream, unsigned char state)
{
struct segment_id_list sid_list={0};
@@ -2060,6 +2084,12 @@ extern "C" unsigned char TSG_MASTER_UDP_ENTRY(const struct streaminfo *a_udp, vo
unsigned char state2=APP_STATE_GIVEME;
struct udp_session_runtime_context *udp_srt_context=(struct udp_session_runtime_context *)(*pme);
int is_ctrl_pkt=session_state_control_packet(a_udp, a_udp->pudpdetail->pdata, a_udp->pudpdetail->datalen);
if(is_ctrl_pkt==1)
{
return APP_STATE_DROPPKT;
}
if(*pme==NULL)
{
unsigned short tunnel_type=0;
@@ -2114,6 +2144,12 @@ extern "C" unsigned char TSG_MASTER_TCPALL_ENTRY(const struct streaminfo *a_tcp,
{
struct session_runtime_action_context *_context=(struct session_runtime_action_context *)(*pme);
int is_ctrl_pkt=session_state_control_packet(a_tcp, a_tcp->ptcpdetail->pdata, a_tcp->ptcpdetail->datalen);
if(is_ctrl_pkt==1)
{
return APP_STATE_DROPPKT;
}
if(*pme==NULL)
{
session_state_sync_in_opening_and_closing(a_tcp, a_tcp->pktstate);

8
src/tsg_proxy.cpp
View File

@@ -21,7 +21,7 @@ enum tsg_proxy_ipv6hdr_parse_error{
TSG_PROXY_IPV6HDR_INVALID_TYPE = -3,
};
int update_segment_sids(struct cmsg_int16_array *d_sids_array, unsigned short *s_sids, unsigned int n_s_sids)
int update_segment_sids(struct tcp_sids *d_sids_array, unsigned short *s_sids, unsigned int n_s_sids)
{
for(unsigned int i=0; i<n_s_sids; i++)
{
@@ -209,7 +209,7 @@ static int tsg_proxy_rawpkt_info_get(const void *raw_pkt, struct tsg_proxy_tcp_o
int ret;
struct segment_id_list *sids = NULL;
ret = get_rawpkt_opt_from_streaminfo(stream, RWA_PKT_GET_SID_LIST, &sids);
ret = get_rawpkt_opt_from_streaminfo(stream, RAW_PKT_GET_SID_LIST, &sids);
if (ret != sizeof(struct segment_id_list)) {
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_FATAL, "PROXY", "Failed to get sid list, stream treaceid = %llu, %s", tsg_get_stream_trace_id(stream), printaddr(&stream->addr, stream->threadnum));
return -1;
@@ -436,8 +436,8 @@ static void tsg_proxy_cmsg_fqdn_category_fill(struct session_runtime_attribute *
{
size_t n_category_ids = 0;
uint32_t category_ids[8] = {0};
struct cmsg_int32_array *fqdn_cat_ids = &cmsg->fqdn_cat_id_val;
struct fqdn_cat_id_val *fqdn_cat_ids = &cmsg->fqdn_cat_ids;
n_category_ids = srt_attribute_get_category_ids(session_attr, category_ids, sizeof(category_ids)/sizeof(category_ids[0]));
if (n_category_ids > 0 && n_category_ids <= 8) {
fqdn_cat_ids->num = n_category_ids;

110
src/tsg_send_log.cpp
View File

@@ -21,6 +21,7 @@
#include "tsg_entry.h"
#include "tsg_bridge.h"
#include "tsg_send_log.h"
#include "tsg_sync_state.h"
#include "tsg_rule_internal.h"
#include "tsg_send_log_internal.h"
@@ -392,7 +393,7 @@ static int set_direction(struct tsg_log_instance_t *_instance, struct TLD_handle
static int set_address_list(struct tsg_log_instance_t *_instance, struct TLD_handle_t *_handle, const struct streaminfo *a_stream)
{
unsigned short tunnel_type=0;
char nest_addr_buf[1024];
char nest_addr_buf[1024]={0};
int tunnel_type_size=sizeof(tunnel_type);
MESA_get_stream_opt(a_stream, MSO_STREAM_TUNNEL_TYPE, &tunnel_type, &tunnel_type_size);
@@ -1362,6 +1363,58 @@ int set_session_flags(struct tsg_log_instance_t *_instance, struct TLD_handle_t
return 0;
}
int set_sce_profile_ids(struct tsg_log_instance_t *_instance, struct TLD_handle_t *_handle, const struct streaminfo *a_stream)
{
struct sce_log_update *sce = (struct sce_log_update *)session_log_update_data_get(a_stream, TSG_SERVICE_CHAINING);
if(sce==NULL)
{
return 0;
}
Value sce_profile_ids_array(kArrayType);
for(size_t i=0; i<sce->n_profile_ids; i++)
{
sce_profile_ids_array.PushBack((unsigned int)(sce->profile_ids[i]), _handle->document->GetAllocator());
}
TLD_append(_handle, _instance->id2field[LOG_COMMON_SCE_PROFILE_IDS].name, (void *) &sce_profile_ids_array, TLD_TYPE_OBJECT);
return 0;
}
int set_shaping_profile_ids(struct tsg_log_instance_t *_instance, struct TLD_handle_t *_handle, const struct streaminfo *a_stream)
{
struct shaper_log_update *shaping = (struct shaper_log_update *)session_log_update_data_get(a_stream, TSG_SERVICE_SHAPING);
if(shaping==NULL)
{
return 0;
}
Value shaping_object(kObjectType);
Value shaping_array(kArrayType);
for(size_t i=0; i<shaping->n_shaper_rule; i++)
{
Value object(kObjectType);
object.AddMember("rule_id", (unsigned int)shaping->shaper_rules[i].rule_id, _handle->document->GetAllocator());
Value shaping_profile_ids_array(kArrayType);
for(size_t j=0; j<shaping->shaper_rules[i].n_profile_ids; j++)
{
shaping_profile_ids_array.PushBack((unsigned long)(shaping->shaper_rules[i].profile_ids[j]), _handle->document->GetAllocator());
}
add_object_member(_handle, &object, "profile_ids", shaping_profile_ids_array)
shaping_array.PushBack(object, _handle->document->GetAllocator());
}
TLD_append(_handle, _instance->id2field[LOG_COMMON_SHAPING_PROFILE_IDS].name, &shaping_array, TLD_TYPE_OBJECT);
//add_object_member(_handle, &shaping_object, _instance->id2field[LOG_COMMON_SHAPING_PROFILE_IDS].name, shaping_array);
return 0;
}
int set_shaping_rule_ids(struct tsg_log_instance_t *_instance, struct TLD_handle_t *_handle, const struct streaminfo *a_stream)
{
if(a_stream==NULL)
@@ -1378,7 +1431,7 @@ int set_shaping_rule_ids(struct tsg_log_instance_t *_instance, struct TLD_handle
Value shaping_rule_ids_array(kArrayType);
for(size_t i=0; i<hited_shaping->n_rules; i++)
{
shaping_rule_ids_array.PushBack((unsigned int)(hited_shaping->rules[i].rule_id), _handle->document->GetAllocator());
shaping_rule_ids_array.PushBack((unsigned long)(hited_shaping->rules[i].rule_id), _handle->document->GetAllocator());
}
TLD_append(_handle, _instance->id2field[LOG_COMMON_SHAPING_RULE_IDS].name, (void *) &shaping_rule_ids_array, TLD_TYPE_OBJECT);
@@ -1689,6 +1742,25 @@ int set_lua_scripts_result(struct tsg_log_instance_t *_instance, struct TLD_hand
return 0;
}
int set_intercept_info(struct tsg_log_instance_t *_instance, struct TLD_handle_t *_handle, const struct streaminfo *a_stream)
{
struct proxy_log_update *proxy = (struct proxy_log_update *)session_log_update_data_get(a_stream, TSG_SERVICE_INTERCEPT);
if(proxy!=NULL)
{
TLD_append(_handle, _instance->id2field[LOG_COMMON_SSL_PINNING_STATE].name, (void *)(long)proxy->ssl_pinning_state, TLD_TYPE_LONG);
TLD_append(_handle, _instance->id2field[LOG_COMMON_SSL_CERT_VERIFY].name, (void *)(long)proxy->ssl_cert_verify, TLD_TYPE_LONG);
TLD_append(_handle, _instance->id2field[LOG_COMMON_SSL_INTERCEPT_STATE].name, (void *)(long)proxy->ssl_intercept_state, TLD_TYPE_LONG);
TLD_append(_handle, _instance->id2field[LOG_COMMON_SSL_UPSTREAM_LATENCY].name, (void *)(long)proxy->ssl_upstream_latency, TLD_TYPE_LONG);
TLD_append(_handle, _instance->id2field[LOG_COMMON_SSL_DOWNSTREAM_LATENCY].name, (void *)(long)proxy->ssl_downstream_latency, TLD_TYPE_LONG);
TLD_append(_handle, _instance->id2field[LOG_COMMON_SSL_UPSTREAM_VERSION].name, proxy->ssl_upstream_version, TLD_TYPE_STRING);
TLD_append(_handle, _instance->id2field[LOG_COMMON_SSL_DOWNSTREAM_VERSION].name, proxy->ssl_downstream_version, TLD_TYPE_STRING);
TLD_append(_handle, _instance->id2field[LOG_COMMON_SSL_ERROR].name, proxy->ssl_error, TLD_TYPE_STRING);
TLD_append(_handle, _instance->id2field[LOG_COMMON_SSL_PASSTHROUGHT_REASON].name, proxy->ssl_passthrough_reason, TLD_TYPE_STRING);
}
return 0;
}
int TLD_append_streaminfo(struct tsg_log_instance_t *instance, struct TLD_handle_t *handle, const struct streaminfo *a_stream)
{
if(instance==NULL || handle==NULL || a_stream==NULL)
@@ -2056,7 +2128,7 @@ int send_log_by_type(struct tsg_log_instance_t *_instance, struct TLD_handle_t *
return 0;
}
int send_security_event_log(struct tsg_log_instance_t *_instance, struct TLD_handle_t *_handle, const struct streaminfo *a_stream, struct maat_rule *rules, size_t n_rules, int thread_id)
int send_event_log(struct tsg_log_instance_t *_instance, struct TLD_handle_t *_handle, const struct streaminfo *a_stream, LOG_TYPE log_type, struct maat_rule *rules, size_t n_rules, int thread_id)
{
int fs_id=0,repeat_cnt=0;
int policy_id[MAX_RESULT_NUM]={0};
@@ -2118,7 +2190,7 @@ int send_security_event_log(struct tsg_log_instance_t *_instance, struct TLD_han
set_xxxx_from_user_region(_handle, _instance, &(rules[i]), thread_id);
send_log_by_type(_instance, _handle, a_stream, LOG_TYPE_SECURITY_EVENT, thread_id);
send_log_by_type(_instance, _handle, a_stream, log_type, thread_id);
TLD_delete(_handle, _instance->id2field[LOG_COMMON_POLICY_ID].name);
TLD_delete(_handle, _instance->id2field[LOG_COMMON_SERVICE].name);
@@ -2166,24 +2238,32 @@ int tsg_send_log(struct tsg_log_instance_t *instance, struct TLD_handle_t *handl
set_application_behavior(_instance, _handle, a_stream);
struct matched_policy_rules *matched_security_rules=NULL;
struct matched_policy_rules *matched_rules=NULL;
switch(log_type)
{
case LOG_TYPE_SECURITY_EVENT:
send_security_event_log(_instance, _handle, a_stream, rules, n_rules, thread_id);
send_event_log(_instance, _handle, a_stream, LOG_TYPE_SECURITY_EVENT, rules, n_rules, thread_id);
break;
case LOG_TYPE_SESSION_RECORD:
case LOG_TYPE_TRANSACTION_RECORD:
matched_security_rules=(struct matched_policy_rules *)session_matched_rules_get(a_stream, TSG_SERVICE_SECURITY);
if(matched_security_rules!=NULL && matched_security_rules->n_rules>0)
matched_rules=(struct matched_policy_rules *)session_matched_rules_get(a_stream, TSG_SERVICE_SECURITY);
if(matched_rules!=NULL && matched_rules->n_rules>0)
{
if(matched_security_rules->rules[0].action!=TSG_ACTION_INTERCEPT)
{
send_security_event_log(_instance, _handle, a_stream, matched_security_rules->rules, matched_security_rules->n_rules, thread_id);
session_matched_rules_free(a_stream, TSG_SERVICE_SECURITY, (void *)matched_security_rules);
session_matched_rules_async(a_stream, TSG_SERVICE_SECURITY, NULL);
}
send_event_log(_instance, _handle, a_stream, LOG_TYPE_SECURITY_EVENT, matched_rules->rules, matched_rules->n_rules, thread_id);
session_matched_rules_free(a_stream, TSG_SERVICE_SECURITY, (void *)matched_rules);
session_matched_rules_async(a_stream, TSG_SERVICE_SECURITY, NULL);
matched_rules=NULL;
}
matched_rules=(struct matched_policy_rules *)session_matched_rules_get(a_stream, TSG_SERVICE_INTERCEPT);
if(matched_rules!=NULL && matched_rules->n_rules>0)
{
set_intercept_info(instance, handle, a_stream);
send_event_log(_instance, _handle, a_stream, LOG_TYPE_INTERCEPT_ENEVT, matched_rules->rules, matched_rules->n_rules, thread_id);
session_matched_rules_free(a_stream, TSG_SERVICE_INTERCEPT, (void *)matched_rules);
session_matched_rules_async(a_stream, TSG_SERVICE_INTERCEPT, NULL);
matched_rules=NULL;
}
// no break;
case LOG_TYPE_INTERIM_SESSION_RECORD:
@@ -2191,6 +2271,8 @@ int tsg_send_log(struct tsg_log_instance_t *instance, struct TLD_handle_t *handl
{
break;
}
set_sce_profile_ids(_instance, _handle, a_stream);
set_shaping_profile_ids(_instance, _handle, a_stream);
set_shaping_rule_ids(_instance, _handle, a_stream);
set_nat_linkinfo(_instance, _handle, a_stream);
send_log_by_type(_instance, _handle, a_stream, log_type, thread_id);

11
src/tsg_send_log_internal.h
View File

@@ -138,6 +138,17 @@ enum LOG_FIELD_ID
LOG_COMMON_FLAGS,
LOG_COMMON_SHAPING_RULE_IDS,
LOG_COMMON_FLAGS_IDENTIFY_INFO,
LOG_COMMON_SSL_PINNING_STATE,
LOG_COMMON_SSL_CERT_VERIFY,
LOG_COMMON_SSL_INTERCEPT_STATE,
LOG_COMMON_SSL_UPSTREAM_LATENCY,
LOG_COMMON_SSL_DOWNSTREAM_LATENCY,
LOG_COMMON_SSL_UPSTREAM_VERSION,
LOG_COMMON_SSL_DOWNSTREAM_VERSION,
LOG_COMMON_SSL_ERROR,
LOG_COMMON_SSL_PASSTHROUGHT_REASON,
LOG_COMMON_SCE_PROFILE_IDS,
LOG_COMMON_SHAPING_PROFILE_IDS,
LOG_COMMON_MAX
};

371
src/tsg_sync_state.cpp
View File

@@ -11,7 +11,7 @@
char *mpack_data = NULL;
size_t mpack_size = 0;
static int tsg_mpack_init_map(const struct streaminfo *a_stream, mpack_writer_t *writer, const char *state)
static int mpack_init_map(const struct streaminfo *a_stream, mpack_writer_t *writer, const char *state)
{
mpack_writer_init_growable(writer, &mpack_data, &mpack_size);
mpack_build_map(writer);
@@ -31,9 +31,9 @@ static int tsg_mpack_init_map(const struct streaminfo *a_stream, mpack_writer_t
return 0;
}
static int tsg_mpack_send_pkt(const struct streaminfo *a_stream, mpack_writer_t *writer)
static int mpack_send_pkt(const struct streaminfo *a_stream, mpack_writer_t *writer)
{
mpack_complete_map(writer); // tsg_mpack_init_map
mpack_complete_map(writer); // mpack_init_map
if (mpack_writer_destroy(writer) != mpack_ok)
{
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_FATAL, "MPACK_WRITER", "An error occurred encoding the data!");
@@ -58,18 +58,18 @@ int tsg_send_session_state(const struct streaminfo *a_stream, unsigned char stat
mpack_writer_t writer;
if (state == OP_STATE_PENDING)
{
tsg_mpack_init_map(a_stream, &writer, "opening");
mpack_init_map(a_stream, &writer, "opening");
}
else if (state == OP_STATE_CLOSE)
{
tsg_mpack_init_map(a_stream, &writer, "closing");
mpack_init_map(a_stream, &writer, "closing");
}
else
{
return -1;
}
return tsg_mpack_send_pkt(a_stream, &writer);
return mpack_send_pkt(a_stream, &writer);
}
int tsg_sync_resetall_state(const struct streaminfo *a_stream)
@@ -80,12 +80,12 @@ int tsg_sync_resetall_state(const struct streaminfo *a_stream)
}
mpack_writer_t writer;
tsg_mpack_init_map(a_stream, &writer, "resetall");
mpack_init_map(a_stream, &writer, "resetall");
return tsg_mpack_send_pkt(a_stream, &writer);
return mpack_send_pkt(a_stream, &writer);
}
static void tsg_mpack_append_str(mpack_writer_t *writer, char *str)
static void mpack_append_string(mpack_writer_t *writer, char *str)
{
if (str)
{
@@ -99,64 +99,67 @@ static void tsg_mpack_append_str(mpack_writer_t *writer, char *str)
return;
}
static void tsg_mpack_append_array_u32(mpack_writer_t *writer, struct cmsg_int32_array *array)
static void mpack_append_fqdn_cat_ids(mpack_writer_t *writer, struct fqdn_cat_id_val *array)
{
if (array->num > 0)
{
mpack_build_array(writer);
for (size_t i = 0; i < array->num; i++)
{
mpack_write_u32(writer, array->value[i]);
}
mpack_complete_array(writer);
}
else
{
mpack_write_nil(writer);
}
int num = MIN(array->num, FQDN_CAT_ID_VALS);
mpack_build_array(writer);
for (int i = 0; i < num; i++)
{
mpack_write_u32(writer, array->value[i]);
}
mpack_complete_array(writer);
}
else
{
mpack_write_nil(writer);
}
return;
return;
}
static void tsg_mpack_append_array_u16(mpack_writer_t *writer, struct cmsg_int16_array *array)
static void mpack_append_tcp_sids(mpack_writer_t *writer, struct tcp_sids *array)
{
if (array->num > 0)
{
mpack_build_array(writer);
for (size_t i = 0; i < array->num; i++)
{
mpack_write_u16(writer, array->value[i]);
}
mpack_complete_array(writer);
}
else
{
mpack_write_nil(writer);
}
int num = MIN(array->num, TCP_XXX_SIDS);
mpack_build_array(writer);
for (int i = 0; i < num; i++)
{
mpack_write_u16(writer, array->value[i]);
}
mpack_complete_array(writer);
}
else
{
mpack_write_nil(writer);
}
return;
return;
}
static void tsg_mpack_append_array_u8(mpack_writer_t *writer, struct cmsg_int8_array *array)
static void mpack_append_route_ctx(mpack_writer_t *writer, struct tcp_route_ctx *array)
{
if (array->num > 0)
{
mpack_build_array(writer);
for (size_t i = 0; i < array->num; i++)
{
mpack_write_u8(writer, array->value[i]);
}
mpack_complete_array(writer);
}
else
{
mpack_write_nil(writer);
}
int num = MIN(array->num, TCP_XXX_ROUTE_CTX);
mpack_build_array(writer);
for (int i = 0; i < num; i++)
{
mpack_write_u8(writer, array->value[i]);
}
mpack_complete_array(writer);
}
else
{
mpack_write_nil(writer);
}
return;
return;
}
static void tsg_mpack_append_cmsg_value(mpack_writer_t *writer, struct proxy_cmsg *cmsg)
static void mpack_append_cmsg_value(mpack_writer_t *writer, struct proxy_cmsg *cmsg)
{
if (cmsg == NULL)
{
@@ -192,44 +195,44 @@ static void tsg_mpack_append_cmsg_value(mpack_writer_t *writer, struct proxy_cms
mpack_write_u32(writer, cmsg->tcp_ts_server_val);
mpack_write_u8(writer, cmsg->tcp_info_packet_cur_dir);
tsg_mpack_append_str(writer, cmsg->src_sub_id);
tsg_mpack_append_str(writer, cmsg->dst_sub_id);
tsg_mpack_append_str(writer, cmsg->src_asn);
tsg_mpack_append_str(writer, cmsg->dst_asn);
tsg_mpack_append_str(writer, cmsg->src_organization);
tsg_mpack_append_str(writer, cmsg->dst_organization);
tsg_mpack_append_str(writer, cmsg->src_ip_location_country);
tsg_mpack_append_str(writer, cmsg->dst_ip_location_country);
tsg_mpack_append_str(writer, cmsg->src_ip_location_provine);
tsg_mpack_append_str(writer, cmsg->dst_ip_location_provine);
tsg_mpack_append_str(writer, cmsg->src_ip_location_city);
tsg_mpack_append_str(writer, cmsg->dst_ip_location_city);
tsg_mpack_append_str(writer, cmsg->src_ip_location_subdivision);
tsg_mpack_append_str(writer, cmsg->dst_ip_location_subdivision);
tsg_mpack_append_str(writer, cmsg->ssl_client_ja3_fingerprint);
mpack_append_string(writer, cmsg->src_sub_id);
mpack_append_string(writer, cmsg->dst_sub_id);
mpack_append_string(writer, cmsg->src_asn);
mpack_append_string(writer, cmsg->dst_asn);
mpack_append_string(writer, cmsg->src_organization);
mpack_append_string(writer, cmsg->dst_organization);
mpack_append_string(writer, cmsg->src_ip_location_country);
mpack_append_string(writer, cmsg->dst_ip_location_country);
mpack_append_string(writer, cmsg->src_ip_location_provine);
mpack_append_string(writer, cmsg->dst_ip_location_provine);
mpack_append_string(writer, cmsg->src_ip_location_city);
mpack_append_string(writer, cmsg->dst_ip_location_city);
mpack_append_string(writer, cmsg->src_ip_location_subdivision);
mpack_append_string(writer, cmsg->dst_ip_location_subdivision);
mpack_append_string(writer, cmsg->ssl_client_ja3_fingerprint);
// fqdn_cat_id_val
tsg_mpack_append_array_u32(writer, &cmsg->fqdn_cat_id_val);
mpack_append_fqdn_cat_ids(writer, &cmsg->fqdn_cat_ids);
// tcp_seq_sids
tsg_mpack_append_array_u16(writer, &cmsg->tcp_seq_sids);
// tcp_seq_sids
mpack_append_tcp_sids(writer, &cmsg->tcp_seq_sids);
// tcp_ack_sids
tsg_mpack_append_array_u16(writer, &cmsg->tcp_ack_sids);
// tcp_ack_sids
mpack_append_tcp_sids(writer, &cmsg->tcp_ack_sids);
// tcp_seq_route_ctx
tsg_mpack_append_array_u8(writer, &cmsg->tcp_seq_route_ctx);
// tcp_seq_route_ctx
mpack_append_route_ctx(writer, &cmsg->tcp_seq_route_ctx);
// tcp_ack_route_ctx
tsg_mpack_append_array_u8(writer, &cmsg->tcp_ack_route_ctx);
// tcp_ack_route_ctx
mpack_append_route_ctx(writer, &cmsg->tcp_ack_route_ctx);
mpack_complete_array(writer); // array
}
mpack_complete_array(writer); // array
}
return;
return;
}
static void tsg_mpack_append_update_policy(mpack_writer_t *writer, struct update_policy *policy_update, enum policy_type type)
static void mpack_append_update_policy(mpack_writer_t *writer, struct update_policy *policy_update, enum policy_type type)
{
switch (type)
{
@@ -250,8 +253,9 @@ static void tsg_mpack_append_update_policy(mpack_writer_t *writer, struct update
mpack_write_cstr(writer, "rule_ids");
if (policy_update->n_ids > 0)
{
int n_ids = MIN(policy_update->n_ids, UPDATE_POLICY_RULE_IDS);
mpack_build_array(writer); // rule_ids
for (int i = 0; i < policy_update->n_ids; i++)
for (int i = 0; i < n_ids; i++)
{
mpack_write_i64(writer, policy_update->ids[i]);
}
@@ -265,7 +269,7 @@ static void tsg_mpack_append_update_policy(mpack_writer_t *writer, struct update
if (type == POLICY_UPDATE_INTERCEPT)
{
mpack_write_cstr(writer, "tcp_handshake");
tsg_mpack_append_cmsg_value(writer, &policy_update->cmsg);
mpack_append_cmsg_value(writer, &policy_update->cmsg);
}
mpack_complete_map(writer); // update_policy_type
@@ -281,7 +285,7 @@ int tsg_sync_policy_update(const struct streaminfo *a_stream, struct update_poli
mpack_writer_t writer;
tsg_mpack_init_map((struct streaminfo *)a_stream, &writer, "active");
mpack_init_map((struct streaminfo *)a_stream, &writer, "active");
// method: policy_update
mpack_write_cstr(&writer, "method");
@@ -292,11 +296,11 @@ int tsg_sync_policy_update(const struct streaminfo *a_stream, struct update_poli
mpack_build_map(&writer);
for (int i = 0; i < (int)n_policy_update; i++)
{
tsg_mpack_append_update_policy(&writer, &policy_update[i], policy_update[i].type);
mpack_append_update_policy(&writer, &policy_update[i], policy_update[i].type);
}
mpack_complete_map(&writer); // params
return tsg_mpack_send_pkt(a_stream, &writer);
return mpack_send_pkt(a_stream, &writer);
}
int tsg_sync_closing_state(const struct streaminfo *a_stream, unsigned char state)
@@ -310,3 +314,206 @@ int tsg_sync_opening_state(const struct streaminfo *a_stream, unsigned char stat
return 0;
}
static char *mpack_parse_get_string(mpack_node_t node, char *p_str, int thread_seq)
{
if (p_str != NULL)
{
dictator_free(thread_seq, p_str);
p_str = NULL;
}
int str_len = 0;
const char *str = NULL;
char *result = NULL;
str = mpack_node_str(node);
str_len = mpack_node_strlen(node);
result = (char *)dictator_malloc(thread_seq, str_len + 1);
memset(result, 0, str_len + 1);
memcpy(result, str, str_len);
return result;
}
static void mpack_parse_intercept_info(mpack_node_t node, struct proxy_log_update *proxy, int thread_seq)
{
if (mpack_node_array_length(node) != (size_t)(SSL_INTERCEPT_MAX_INDEX))
{
return;
}
proxy->ssl_intercept_state = mpack_node_u8(mpack_node_array_at(node, SSL_INTERCEPT_STATE));
proxy->ssl_upstream_latency = mpack_node_u64(mpack_node_array_at(node, SSL_UPSTREAM_LATENCY));
proxy->ssl_downstream_latency = mpack_node_u64(mpack_node_array_at(node, SSL_DOWNSTREAM_LATENCY));
proxy->ssl_upstream_version = mpack_parse_get_string(mpack_node_array_at(node, SSL_UPSTREAM_VERSION), proxy->ssl_upstream_version, thread_seq);
proxy->ssl_downstream_version = mpack_parse_get_string(mpack_node_array_at(node, SSL_DOWNSTREAM_VERSION), proxy->ssl_downstream_version, thread_seq);
proxy->ssl_pinning_state = mpack_node_u8(mpack_node_array_at(node, SSL_PINNING_STATE));
proxy->ssl_cert_verify = mpack_node_u8(mpack_node_array_at(node, SSL_CERT_VERIFY));
proxy->ssl_error = mpack_parse_get_string(mpack_node_array_at(node, SSL_ERROR), proxy->ssl_error, thread_seq);
proxy->ssl_passthrough_reason = mpack_parse_get_string(mpack_node_array_at(node, SSL_PASSTHROUGH_REASON), proxy->ssl_passthrough_reason, thread_seq);
return;
}
static void mpack_parse_append_profile_id(mpack_node_t profile_ids_node, uint32_t *ids, size_t *n_id, size_t max)
{
*n_id = MIN(mpack_node_array_length(profile_ids_node), max);
for (int i = 0; i < (int)(*n_id); i++)
{
ids[i] = mpack_node_u32(mpack_node_array_at(profile_ids_node, i));
}
return;
}
int mpack_parse_sce_profile_ids(const struct streaminfo *a_stream, mpack_tree_t tree, mpack_node_t sce_node)
{
mpack_node_t sf_profile_ids = mpack_node_map_cstr(sce_node, "sf_profile_ids");
if (mpack_node_type(sf_profile_ids) != mpack_type_array)
{
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_SCE", "sf_profile_ids error! mpack_node_type(sf_profile_ids): %d", (int)mpack_node_type(sf_profile_ids));
mpack_tree_destroy(&tree);
return -1;
}
struct sce_log_update *sce_handle = (struct sce_log_update *)session_log_update_data_get(a_stream, TSG_SERVICE_CHAINING);
if (sce_handle == NULL)
{
sce_handle = (struct sce_log_update *)dictator_malloc(a_stream->threadnum, sizeof(struct sce_log_update));
memset(sce_handle, 0, sizeof(struct sce_log_update));
session_log_update_data_put(a_stream, TSG_SERVICE_CHAINING, (void *)sce_handle);
}
mpack_parse_append_profile_id(sf_profile_ids, sce_handle->profile_ids, &sce_handle->n_profile_ids, SCE_PROFILE_IDS);
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_DEBUG, "PARSE_SCE", "n_profile_ids: %lu;", sce_handle->n_profile_ids);
mpack_tree_destroy(&tree);
return 0;
}
int mpack_parse_shaper_profile_ids(const struct streaminfo *a_stream, mpack_tree_t tree, mpack_node_t shaper_node)
{
struct shaper_log_update *shaper_handle = (struct shaper_log_update *)session_log_update_data_get(a_stream, TSG_SERVICE_SHAPING);
if (shaper_handle == NULL)
{
shaper_handle = (struct shaper_log_update *)dictator_malloc(a_stream->threadnum, sizeof(struct shaper_log_update));
memset(shaper_handle, 0, sizeof(struct shaper_log_update));
session_log_update_data_put(a_stream, TSG_SERVICE_SHAPING, (void *)shaper_handle);
}
shaper_handle->n_shaper_rule = MIN(mpack_node_array_length(shaper_node), SHAPR_RULE_IDS);
mpack_node_t sh_ids_node;
for (int i = 0; i < (int)shaper_handle->n_shaper_rule; i++)
{
sh_ids_node = mpack_node_array_at(shaper_node, i);
shaper_handle->shaper_rules[i].rule_id = mpack_node_i64(mpack_node_map_cstr(sh_ids_node, "rule_id"));
mpack_parse_append_profile_id(mpack_node_map_cstr(sh_ids_node, "profile_ids"), shaper_handle->shaper_rules[i].profile_ids, &shaper_handle->shaper_rules[i].n_profile_ids, SHAPR_PROFILE_IDS);
}
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_DEBUG, "PARSE_SHAPER", "n_sh_profile_ids: %lu;", shaper_handle->n_shaper_rule);
mpack_tree_destroy(&tree);
return 0;
}
int mpack_parse_proxy_intercept_info(const struct streaminfo *a_stream, mpack_tree_t tree, mpack_node_t proxy_node)
{
mpack_node_t ssl_intercept_info = mpack_node_map_str_optional(proxy_node, "ssl_intercept_info", 18);
if (mpack_node_type(ssl_intercept_info) != mpack_type_array)
{
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_PROXY", "ssl_intercept_info error! mpack_node_type(ssl_intercept_info): %d", (int)mpack_node_type(ssl_intercept_info));
mpack_tree_destroy(&tree);
return -1;
}
struct proxy_log_update *proxy_handle = (struct proxy_log_update *)session_log_update_data_get(a_stream, TSG_SERVICE_INTERCEPT);
if (proxy_handle == NULL)
{
proxy_handle = (struct proxy_log_update *)dictator_malloc(a_stream->threadnum, sizeof(struct proxy_log_update));
memset(proxy_handle, 0, sizeof(struct proxy_log_update));
session_log_update_data_put(a_stream, TSG_SERVICE_INTERCEPT, (void *)proxy_handle);
}
mpack_parse_intercept_info(ssl_intercept_info, proxy_handle, a_stream->threadnum);
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_DEBUG,
"PARSE_PROXY",
"ssl_intercept_state: %u; ssl_upstream_latency: %llu; ssl_downstream_latency: %llu; ssl_upstream_version: %s; ssl_downstream_version: %s; ssl_pinning_state: %u; ssl_cert_verify: %u; ssl_error: %s; ssl_passthrough_reason: %s;",
proxy_handle->ssl_intercept_state,
proxy_handle->ssl_upstream_latency,
proxy_handle->ssl_downstream_latency,
proxy_handle->ssl_upstream_version,
proxy_handle->ssl_downstream_version,
proxy_handle->ssl_pinning_state,
proxy_handle->ssl_cert_verify,
proxy_handle->ssl_error,
proxy_handle->ssl_passthrough_reason);
mpack_tree_destroy(&tree);
return 0;
}
int tsg_parse_log_update_payload(const struct streaminfo *a_stream, const void *payload, unsigned int payload_len)
{
if (a_stream == NULL || payload == NULL || payload_len == 0)
{
return -1;
}
mpack_tree_t tree;
mpack_tree_init_data(&tree, (const char *)payload, payload_len);
mpack_tree_parse(&tree);
mpack_node_t root = mpack_tree_root(&tree);
mpack_node_t method = mpack_node_map_cstr(root, "method");
if (mpack_node_type(method) != mpack_type_str)
{
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_LOG_UPDATE", "method error! mpack_node_type(method) = %d", (int)mpack_node_type(method));
mpack_tree_destroy(&tree);
return -1;
}
if (mpack_node_strlen(method) != strlen("log_update") || memcmp("log_update", mpack_node_str(method), strlen("log_update")) != 0)
{
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_LOG_UPDATE", "method error! mpack_node_strlen(method) = %lu", mpack_node_strlen(method));
mpack_tree_destroy(&tree);
return -1;
}
uint64_t session_id = mpack_node_u64(mpack_node_map_cstr(root, "session_id"));
if (session_id != tsg_get_stream_trace_id(a_stream))
{
// if session_id = 0, it's could be mpack_node_type(root) = nil
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_LOG_UPDATE", "session_id error! session_id: %llu, real session_id: %llu", session_id, tsg_get_stream_trace_id(a_stream));
mpack_tree_destroy(&tree);
return -1;
}
mpack_node_t params_node = mpack_node_map_cstr(root, "params");
if (mpack_node_type(params_node) == mpack_type_nil)
{
MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_INFO, "PARSE_LOG_UPDATE", "params_node error!");
mpack_tree_destroy(&tree);
return -1;
}
mpack_node_t temp_node = mpack_node_map_str_optional(params_node, "sce", 3);
if (mpack_node_type(temp_node) != mpack_type_nil && mpack_node_type(temp_node) != mpack_type_missing)
{
return mpack_parse_sce_profile_ids(a_stream, tree, temp_node);
}
temp_node = mpack_node_map_str_optional(params_node, "shaper", 6);
if (mpack_node_type(temp_node) != mpack_type_nil && mpack_node_type(temp_node) != mpack_type_missing)
{
return mpack_parse_shaper_profile_ids(a_stream, tree, temp_node);
}
temp_node = mpack_node_map_str_optional(params_node, "proxy", 5);
if (mpack_node_type(temp_node) != mpack_type_nil && mpack_node_type(temp_node) != mpack_type_missing)
{
return mpack_parse_proxy_intercept_info(a_stream, tree, temp_node);
}
return -1;
}

95
src/tsg_sync_state.h
View File

@@ -11,30 +11,45 @@ enum policy_type
POLICY_UPDATE_MAX
};
struct cmsg_int32_array
enum ssl_intercept_info_index
{
size_t num;
uint32_t value[8];
SSL_INTERCEPT_STATE = 0,
SSL_UPSTREAM_LATENCY,
SSL_DOWNSTREAM_LATENCY,
SSL_UPSTREAM_VERSION,
SSL_DOWNSTREAM_VERSION,
SSL_PINNING_STATE,
SSL_CERT_VERIFY,
SSL_ERROR,
SSL_PASSTHROUGH_REASON,
SSL_INTERCEPT_MAX_INDEX
};
struct cmsg_int16_array
#define FQDN_CAT_ID_VALS 8
struct fqdn_cat_id_val
{
size_t num;
uint16_t value[8];
uint32_t value[FQDN_CAT_ID_VALS];
};
struct cmsg_int8_array
#define TCP_XXX_SIDS 8
struct tcp_sids
{
size_t num;
uint8_t value[64];
uint16_t value[TCP_XXX_SIDS];
};
#define TCP_XXX_ROUTE_CTX 64
struct tcp_route_ctx
{
size_t num;
uint8_t value[TCP_XXX_ROUTE_CTX];
};
struct proxy_cmsg
{
uint32_t tcp_seq;
uint32_t tcp_ack;
uint16_t tcp_mss_client;
uint16_t tcp_mss_server;
uint8_t tcp_info_packet_cur_dir;
uint8_t tcp_wsacle_exist;
uint8_t tcp_wsacle_client;
uint8_t tcp_wsacle_server;
@@ -43,11 +58,15 @@ struct proxy_cmsg
uint8_t tcp_ts_client;
uint8_t tcp_ts_server;
uint8_t tcp_protocol;
uint16_t tcp_mss_client;
uint16_t tcp_mss_server;
uint16_t tcp_window_client;
uint16_t tcp_window_server;
uint32_t tcp_ts_client_val;
uint32_t tcp_ts_server_val;
uint8_t tcp_info_packet_cur_dir;
uint32_t tcp_seq;
uint32_t tcp_ack;
char *src_sub_id;
char *dst_sub_id;
char *src_asn;
@@ -63,25 +82,63 @@ struct proxy_cmsg
char *src_ip_location_subdivision;
char *dst_ip_location_subdivision;
char *ssl_client_ja3_fingerprint;
struct cmsg_int32_array fqdn_cat_id_val;
struct cmsg_int16_array tcp_seq_sids;
struct cmsg_int16_array tcp_ack_sids;
struct cmsg_int8_array tcp_seq_route_ctx;
struct cmsg_int8_array tcp_ack_route_ctx;
struct fqdn_cat_id_val fqdn_cat_ids;
struct tcp_sids tcp_seq_sids;
struct tcp_sids tcp_ack_sids;
struct tcp_route_ctx tcp_seq_route_ctx;
struct tcp_route_ctx tcp_ack_route_ctx;
};
#define UPDATE_POLICY_RULE_IDS 8
struct update_policy
{
enum policy_type type;
int n_ids;
long long ids[8];
long long ids[UPDATE_POLICY_RULE_IDS];
struct proxy_cmsg cmsg;
};
struct proxy_log_update
{
uint8_t ssl_pinning_state;
uint8_t ssl_cert_verify;
uint8_t ssl_intercept_state;
uint64_t ssl_upstream_latency;
uint64_t ssl_downstream_latency;
char *ssl_upstream_version;
char *ssl_downstream_version;
char *ssl_error;
char *ssl_passthrough_reason;
};
#define SHAPR_PROFILE_IDS 8
struct shaper_rule
{
long long rule_id;
size_t n_profile_ids;
uint32_t profile_ids[SHAPR_PROFILE_IDS];
};
#define SHAPR_RULE_IDS 8
struct shaper_log_update
{
size_t n_shaper_rule;
struct shaper_rule shaper_rules[SHAPR_RULE_IDS];
};
#define SCE_PROFILE_IDS 8
struct sce_log_update
{
size_t n_profile_ids;
uint32_t profile_ids[SCE_PROFILE_IDS];
};
int tsg_sync_resetall_state(const struct streaminfo *a_stream);
int tsg_send_session_state(const struct streaminfo *a_stream, unsigned char state);
int tsg_sync_opening_state(const struct streaminfo *a_stream, unsigned char state);
int tsg_sync_closing_state(const struct streaminfo *a_stream, unsigned char state);
int tsg_sync_policy_update(const struct streaminfo *a_stream, struct update_policy *policy_update, size_t n_policy_update);
// int tsg_recv_control_pkt(const struct streaminfo *a_stream, const void *payload, int payload_len);
int tsg_parse_log_update_payload(const struct streaminfo *a_stream, const void *payload, unsigned int payload_len);