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