NODLINK：一个细粒度APT攻击在线检测与调查系统

NODLINK：一个细粒度APT攻击在线检测与调查系统

​Github：http://Github：https://github.com/PKU-ASAL/Simulated-Data?tab=readme-ov-file
NODLINK: An Online System for Fine-Grained APT Attack Detection and Investigation

环境配置

conda create --name env1 python=3.11
conda activate env1
pip install git+https://github.com/casics/nostril.git
pip install scikit-learn
pip install networkx
pip install gensim==4.2.0
pip install matplotlib==3.3.4
pip install networkx==2.5
pip install numpy==1.20.1
pip install pandas==1.2.4
pip install tqdm==4.62.3

代码解读

预处理数据

python process_behavior.py --file benign.json

process_behavior.py（路径：src/Sysdig/process_behavior.py）

一、原始数据

1.benign.json（数据示例）

key	value
evt.args	"res=0 "
evt.num	5414
evt.time	1648196412403647385
evt.type	“fstat”
fd.name	“”/root/data""
proc.cmdline	“node /root/.vscode-server/bin/ccbaa2d27e38e5afa3e5c21c1c7bef4657064247/out/bootstrap-fork --type=watcherServiceChokidar”
proc.name	“node”
proc.pcmdline	“node /root/.vscode-server/bin/ccbaa2d27e38e5afa3e5c21c1c7bef4657064247/out/vs/server/main.js --start-server --host=127.0.0.1 --enable-remote-auto-shutdown --port=0 --connection-secret /root/.vscode-server/.ccbaa2d27e38e5afa3e5c21c1c7bef4657064247.token”
proc.pname	“node”

2.anomaly.json（数据示例）

key	value
evt.args	"res=0 "
evt.num	195
evt.time	1648192288041289626
evt.type	“fstat”
fd.name	“/root/data”
proc.cmdline	“node /root/.vscode-server/bin/ccbaa2d27e38e5afa3e5c21c1c7bef4657064247/out/bootstrap-fork --type=watcherServiceChokidar”
proc.name	“node”
proc.pcmdline	“node /root/.vscode-server/bin/ccbaa2d27e38e5afa3e5c21c1c7bef4657064247/out/vs/server/main.js --start-server --host=127.0.0.1 --enable-remote-auto-shutdown --port=0 --connection-secret /root/.vscode-server/.ccbaa2d27e38e5afa3e5c21c1c7bef4657064247.token”
proc.pname	“node”
is_warn	false

二、代码解读

1.process_behavior

if __name__ == "__main__":
	# 接收控制台参数
    parser = ArgumentParser()
    # 指定要解析的json文件名
    parser.add_argument("--file",type = str, default='benign-labeled.json')
    # 指定json文件所在的目录
    parser.add_argument("--d",type = str, default = 'hw17')
    args = parser.parse_args()
    file_path = args.file
    dataset = args.d
    # 初始化一个有向图
    G = nx.DiGraph()
    # 逐行读取日志文件，返回一个DataFrame对象
    org_log = read_org_log_from_json(dataset + '/' + file_path)
	
	# 判断文件操作FILE_OP是否在org_log的evt.type列中，记录与文件操作相关的行
    file_op_logs = org_log[org_log['evt.type'].isin(APTLOG_TYPE.FILE_OP)]
    print('file logs count:', len(file_op_logs))
    # 记录与进程操作相关的日志行
    process_op_logs = org_log[org_log['evt.type'].isin(APTLOG_TYPE.PROCESS_OP)]
    print('process logs count:', len(process_op_logs))
    # 记录与网络操作相关的行
    net_op_logs = org_log[org_log['evt.type'].isin(APTLOG_TYPE.NET_OP)]
    print('net logs count:', len(net_op_logs))
    # execve_op_logs = org_log[org_log['evt.type'].isin(APTLOG_TYPE.EXECVE_OP)]
    # print('execve logs count:', len(execve_op_logs))

    if len(file_op_logs) > 0:
        file_op_logs = file_op_logs[APTLOG_ARTRIBUTE.FILE_ARTRIBUTE]
    if len(process_op_logs) > 0:
        process_op_logs = process_op_logs[APTLOG_ARTRIBUTE.PROCESS_ARTRIBUTE]
    if len(net_op_logs) > 0:
        net_op_logs = net_op_logs[APTLOG_ARTRIBUTE.NET_ARTRIBUTE]
    # if len(execve_op_logs) > 0:
    #     execve_op_logs = execve_op_logs[APTLOG_ARTRIBUTE.EXECVE_ARTRIBUTE]
	
	# 初始化一个空的有向图
    G = graph_init()

    md5_to_node = {}
    node_to_type = {}
    anomalyset = set()
    # 将FILE节点添加到图G中
    G, x = graph_add_node_realapt(G, file_op_logs, APTLOG_KEY.FILE, md5_to_node, node_to_type)
    anomalyset |= x
    # 将PROCESS节点添加到图G中
    G, x = graph_add_node_realapt(G, process_op_logs, APTLOG_KEY.PROCESS, md5_to_node, node_to_type)
    anomalyset |= x
    # 将NET节点添加到图G中
    G, x = graph_add_node_realapt(G, net_op_logs, APTLOG_KEY.NET, md5_to_node, node_to_type)
    anomalyset |= x
    # 经过上边3步，得到了包含全部节点和边的有向图G和异常节点集合anomalyset（节点都以md5值标识）
    print(len(anomalyset))
    # G = graph_add_node_realapt(G, execve_op_logs, APTLOG_KEY.EXECVE, md5_to_node, node_to_type)

    # nx.drawing.nx_pydot.write_dot(G, 'test.dot')
    # DAG = directed_acyclic_graph(graph=G)

    # print(len(G.nodes))
    # for i,g in enumerate(nx.weakly_connected_components(G)):
    #     subgraph = G.subgraph(g)
    #     nx.drawing.nx_pydot.write_dot(subgraph, str(i) + '.dot')

    attack_process = set()
    # DAG = directed_acyclic_graph(graph=G)
    is_anomaly = True
    # 依据处理的json文件是良性活动还是包含攻击活动的，决定is_anomaly和event_file的取值
    if 'benign' in file_path:
        is_anomaly = False
        # event_file指定了最终输出的结果txt文件路径
        event_file = dataset + '/process-event-benign.txt'
    else:
        event_file = dataset + '/process-event-anomaly.txt'
    # 以写的方式打开结果文件
    data = open(event_file,'w')
    for node in G:
    	# 处理图中PROCESS类型的顶点
        if G.nodes[node]['type'] == APTLOG_NODE_TYPE.PROCESS:
        	# 顶点取值有意义
            if G.nodes[node]['label'] != '':
            	# 当前处理的是包含攻击活动的json文件时
                if is_anomaly:
                	# 将异常节点以 label（即取值）$$$is_warn 的形式记录到结果文件中
                    data.write(G.nodes[node]['label'] + '$$$' + str(G.nodes[node]['is_warn']) +'\n')
                    if G.nodes[node]['is_warn']:
                    	# 将is_warn值为真的顶点添加到attack_process集合中
                        attack_process.add(node)
				
				# 当前处理的是良性活动的json文件时
                else:
                	# 以label（即取值）的形式写入结果文档
                    data.write(G.nodes[node]['label'] + '\n')
                # data.write(G.nodes[node]['label'] + '\n')
                
                 # 遍历当前节点node的全部后续节点
                for i in G.successors(node):
                	# 若后续节点的值有意义、不是'unknown'且节点不是PROCESS类型，则将其写入结果文档中
                    if G.nodes[i]['label'] != 'unknown' and G.nodes[i]['type'] != APTLOG_NODE_TYPE.PROCESS and G.nodes[i]['label'] != '':
                        data.write(G.nodes[i]['label'] + '\n')
                # 遍历当前节点node的全部前驱节点
                for i in G.predecessors(node):
                	# 若前驱节点的值有意义、不是'unknown'且节点不是PROCESS类型，则将其写入结果文档中
                    if G.nodes[i]['label'] != 'unknown' and G.nodes[i]['type'] != APTLOG_NODE_TYPE.PROCESS and G.nodes[i]['label'] != '':
                        data.write(G.nodes[i]['label'] + '\n')
                data.write('\n')

    data.close()
    # 打印is_warn值为真的顶点集合（存放的是md5值）
    print(attack_process)
    # 若处理的是良性活动文件，则要将event_file中的命令行和文件部分分别记录到两个文件中
    if 'benign' in event_file:
        split_cmd_and_filename(event_file,dataset)

2.辅助函数

（1）split_cmd_and_filename

# 将file_path的每行内容划分为命令行和文件名两部分，分别写入到两个txt文件中
def split_cmd_and_filename(file_path,dataset):
	# 以读的方式打开结果txt文本
    f = open(file_path,'r')
    # 以写的方式在数据目录下打开两个文本文件
    o1 = open(dataset+'/cmdline.txt','w')
    o2 = open(dataset+'/filename.txt','w')
    print('start graph')
    isprocess_file = True
    while True:
    	# 按行读取txt文件中的数据
        line = f.readline()
        if line == '\n':
            isprocess_file = True
            continue
        if not line:
            break
        # 去除首位空格并转换为小写
        filepath = line.strip().lower()
        # 判断是否以 $$$true 结尾
        if filepath.endswith('$$$true'):
        	# 将 '$$$true' 替换为 ' '
            filepath = filepath.replace('$$$true','')
        elif filepath.endswith('$$$false'):
        	# 将 '$$$false' 替换为 ' '
            filepath = filepath.replace('$$$false','')

        split_path = sanitize_string(filepath)
        if len(split_path) == 0:
            continue

        if isprocess_file:
            o1.write(filepath + '\n')
            isprocess_file = False
        else:
            o2.write(filepath + '\n')
    o1.close()
    o2.close()

（2）graph_add_node_realapt

# 向图中添加顶点和边
def graph_add_node_realapt(g: nx.Graph, logs, key, md5_to_node:dict, node_to_type:dict):
    node_set = set()
    edge_set = set()
    anomaly_set = set()
    # 将FILE类型节点添加到图中
    if key == APTLOG_KEY.FILE:
    	# 按行遍历FILE类型的logs，index是行名，row是此行的数据(Series类型)
        for index, row in logs.iterrows():
        	# 获取每条FILE日志的proc.cmdline属性值的md5值
            s_node = get_md5(row['proc.cmdline'])
            # 获取每条FILE日志的fd.name属性值的md5值
            t_node = get_md5(row['fd.name'])
            # 将新的(s_node,row['proc.cmdline'])添加到字典md5_to_node中
            if s_node not in md5_to_node:
            	# 记录各个md5值和命令行值的映射
                md5_to_node[s_node] = row['proc.cmdline']
                # 记录各个md5值和对应类型、is_warn的映射
                node_to_type[s_node] = {'type':APTLOG_NODE_TYPE.PROCESS, 'is_warn':row['is_warn']}
            # 将新的(t_node,row['fd.name'])添加到字典md5_to_node中
            if t_node not in md5_to_node:
            	# 记录各个md5值和fd.name的映射
                md5_to_node[t_node] = row['fd.name']
                # 记录各个md5值和对应类型、is_warn的映射
                node_to_type[t_node] = {'type':APTLOG_NODE_TYPE.FILE, 'is_warn':False}
            # e_id = row['log_id']
            is_warn = row['is_warn']
            # 将被标记为警报的日志对应的md5值加入到异常集合中
            if is_warn:
                anomaly_set.add(s_node)
            # 将文件命令行proc.cmdline和文件名字fd.name属性值对应的md5值添加到node_set集合中
            node_set.add(s_node)
            node_set.add(t_node)
            # 将(文件命令行md5值，文件名字md5值,是否警报)添加到edge_set集合中
            edge_set.add((s_node, t_node, is_warn))
    # 将PROCESS类型节点添加到图中
    elif key == APTLOG_KEY.PROCESS:
        for index, row in logs.iterrows():
            s_node = get_md5(row['proc.pcmdline'])
            t_node = get_md5(row['proc.cmdline'])
            if s_node not in md5_to_node:
                md5_to_node[s_node] = row['proc.pcmdline']
                node_to_type[s_node] = {'type':APTLOG_NODE_TYPE.PROCESS, 'is_warn':row['is_warn']}
            if t_node not in md5_to_node:
                md5_to_node[t_node] = row['proc.cmdline']
                node_to_type[t_node] = {'type':APTLOG_NODE_TYPE.PROCESS, 'is_warn':row['is_warn']}
            # e_id = row['log_id']
            is_warn = row['is_warn']
            if is_warn:
                anomaly_set.add(s_node)
                anomaly_set.add(t_node)
            # 将进程命令行proc.pcmdline和文件命令行proc.cmdline属性值对应的md5值添加到node_set集合中
            node_set.add(s_node)
            node_set.add(t_node)
            # 将（进程命令行md5值，文件命令行md5值，是否警报）添加到edge_set集合中
            edge_set.add((s_node, t_node, is_warn))
    # 将NET类型节点添加到图中
    elif key == APTLOG_KEY.NET:
        # add net type node
        for index, row in logs.iterrows():
            s_node = get_md5(row['proc.cmdline'])
            t_node = get_md5(row['fd.name'])
            if s_node not in md5_to_node:
                md5_to_node[s_node] = row['proc.cmdline']
                node_to_type[s_node] = {'type':APTLOG_NODE_TYPE.PROCESS, 'is_warn':row['is_warn']}
            if t_node not in md5_to_node:
                md5_to_node[t_node] = row['fd.name']
                node_to_type[t_node] = {'type':APTLOG_NODE_TYPE.NET, 'is_warn':False}
            # e_id = row['log_id']
            is_warn = row['is_warn']
            if is_warn:
                anomaly_set.add(s_node)
            # 将文件命令行proc.cmdline和文件名字fd.name属性值对应的md5值添加到node_set集合中
            node_set.add(s_node)
            node_set.add(t_node)
            # 将（文件命令行md5值，文件名字md5值，是否警报）添加到edge_set集合中
            edge_set.add((s_node, t_node, is_warn))

    # add node
    # 将节点md5值的集合转换为列表存在node_list中
    node_list = list(node_set)
    node_list.sort()
    for node in node_list:
    	# 向图中增加节点node
        g.add_node(node)
        # 对图中各个顶点记录其label（取值）、类型（FILE/PROCESS/NET）和is_warn
        g.nodes[node]['label'] = md5_to_node[node]
        g.nodes[node]['type'] = node_to_type[node]['type']
        g.nodes[node]['is_warn'] = node_to_type[node]['is_warn']

    # add edge
    # 将边的集合edge_set转换为列表存在edge_list中
    edge_list = list(edge_set)
    edge_list.sort()
    for edge in edge_list:
    	# 向图中添加边
        g.add_edge(edge[0], edge[1], is_warn=edge[2])

    return g,anomaly_set