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

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

​Github：https://github.com/PKU-ASAL/Simulated-Data/tree/main
NODLINK: An Online System for Fine-Grained APT Attack Detection and Investigation

复现记录

1. 环境配置

复现机器

conda create --name nodlink python=3.12
conda activate nodlink
pip install git+https://github.com/casics/nostril.git
pip install scikit-learn
pip install networkx
pip install gensim
pip install matplotlib
pip install pandas
pip install tqdm
pip install scipy==1.12
pip install seaborn

2. 预处理数据

cd Simulated-Data/src/Sysdig/
python process_behavior.py --file benign.json
python process_behavior.py --file anomaly.json

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

原始数据

属性名	含义
evt.args	事件的参数，通常记录了与事件相关的具体信息
evt.num	事件编号，用于唯一标识每个事件
evt.time	事件发生的时间戳
evt.type	事件类型（如读取、写入、文件状态检查等）
fd.name	文件描述符的名称，通常是与事件相关的文件或设备的路径
proc.cmdline	进程命令行，表示触发该事件的进程及其命令行参数
proc.name	进程名称，表示触发该事件的进程的名称
proc.pcmdline	父进程命令行，表示触发该事件的进程的父进程及其命令行参数
proc.pname	父进程名称，表示触发该事件的进程的父进程的名称

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

良性系统事件：
对于文件相关的系统事件，提取：‘proc.cmdline’ 和 ‘fd.name’；（proc.cmdline作为s_node，'fd.name作为t_node）

{"evt.args":"fd=6(<f>/proc/3/cmdline) size=131072 ","evt.num":27064,"evt.time":1648196413591314739,"evt.type":"read","fd.name":"/proc/3/cmdline","proc.cmdline":"ps -ax -o pid=,ppid=,pcpu=,pmem=,command=","proc.name":"ps","proc.pcmdline":"sh -c /usr/bin/ps -ax -o pid=,ppid=,pcpu=,pmem=,command=","proc.pname":"sh"}

进程相关的事件，提取：‘proc.pcmdline’ 和 ‘proc.cmdline’；（proc.pcmdline作为s_node，proc.cmdline作为t_node）

{"evt.args":"res=296477(sh) exe=/bin/sh args=-c.which ps. tid=296476(sh) pid=296476(sh) ptid=296004(node) cwd= fdlimit=65535 pgft_maj=0 pgft_min=105 vm_size=2608 vm_rss=608 vm_swap=0 comm=sh cgroups=cpuset=/.cpu=/.cpuacct=/.io=/.memory=/user.slice/user-0.slice/session-725.scope.devices=/user.slice.freezer=/.net_cls=/.perf_event=/.net_prio=/.hugetlb=/.pids=/user.slice/user-0.slice/session-725.scope.rdma=/. flags=25165824(CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID) uid=0 gid=0 vtid=296476(sh) vpid=296476(sh) ","evt.num":26140,"evt.time":1648196413587366329,"evt.type":"clone","fd.name":null,"proc.cmdline":"sh -c which ps","proc.name":"sh","proc.pcmdline":"node /root/.vscode-server/bin/ccbaa2d27e38e5afa3e5c21c1c7bef4657064247/out/bootstrap-fork --type=ptyHost","proc.pname":"node"}

Socket相关的事件，提取：‘proc.cmdline’ 和 ‘fd.name’

3. 离线模型训练

python filename-embedding.py
python cmdline-embedding.py
python caculate-weight.py

直接计算权重会报错，

需进行以下修改

python train.py --epoch 50

这里会报上边的错误，使用同样方法解决

4. 在线检测

pip install streamz
pip install nearpy
pip install schedule
python main.py --t 0.7

运行结果

实验

1.论文实验部分

探索问题：

(1) NODLINK能否实现比SOTA解决方案更高的图级精度？
(2) NODLINK能否实现比SOTA解决方案更高的节点级精度？
(3) NODLINK能否实现比SOTA解决方案更高的检测效率？
(4) NODLINK的优化对效率有什么影响？
(5) NODLINK能否有效地检测和恢复生产环境中的真实攻击场景？
(6) 超参数如何影响NODLINK的性能？

（1）实验工具

NODLINK利用工业EDR的代理从受监控主机收集起源数据。收集的数据具有与其他检测系统(Unicorn和Holmes)相同的格式。

对比Baeline：
①基于起源的在线APT检测系统：Holmes（基于SOTA规则）和Unicorn（基于SOTA学习）
②基于起源的离线检测恶意软件系统：ProvDetector

评估APT检测系统的主要挑战是避免“封闭世界数据”的问题，也就是基于会导致过度拟合的已知数据集来构建解决方案。为此，实验部分使用从封闭世界实验中获得的参数，通过将NODLINK部署到现实的生产环境中来进行开放世界实验。

（2）评估指标

图级准确率

• 图级准确率：GTP/(GTP+GFP)
• 图级召回率：GTP/(GTP+GFN)
• GTP：起源图包含攻击步骤并被报告为警报，则称该图为GTP
• GFP：起源图不包含攻击步骤但被识别为警报，则称该图为GFP
• GFN：起源图包含攻击步骤但未被标识为警报，则称该图为GFN

节点级准确率

• 节点级准确率：NTP/(NTP+NFP)
• 节点级召回率：NTP/(NTP+NFN)
• NTP：起源图中的节点与攻击相关并且包含在警报中，则称该节点为NTP
• NFP：起源图中的节点与攻击无关并且包含在警报，则称该节点为NFP
• NFN：起源图中的节点与攻击相关但未包含在警报中，则称该节点为NFN

（3）封闭世界实验

在封闭世界实验中构建了5个数据集，前3个是来自DARPA TC E3数据库的CADETS、THEIA和TRACE，另外构建了两个现实生产环境的数据集Industrial Arena和In-Lab Arena。
除了Industrial Arena数据集，还构建了一个较小的试验台，模拟Sangfor的内部环境，并将收集的数据公开提供（即源码中给出的三个zip数据集）。数据收集自五台主机：一台Ubuntu 20.04服务器、两台Windows Server 2012 R2数据中心、一台Windows Server 2019数据中心和一台Windows 10桌面主机。
对于每个数据集，将其良性数据划分为训练集(80%的图)和测试数据集(20%的图)。然后，在良性训练集上训练检测模型，并在测试集和攻击数据上评估NODLINK的性能。为了从DARPA TC获得三个数据集的GT，首先根据DARPA提供的文件对攻击进行标记。利用Sangfor的红色团队来标记他们为Industrial Arena数据集和In-Lab Arena数据集所做的攻击步骤。

（4）开放世界实验

在开放世界评估中，我们将NODLINK和Baseline集成到Sangfor EDR的测试版中，并将它们部署到监控现实客户的系统。基于在“封闭世界数据”中的DARPA数据集微调NODLINK和Baeline的超参数，并将微调后的模型直接部署到“开放世界数据”中。
开放世界评估用于评估NODLINK在生产环境中检测真实攻击的能力。
开放世界评估包括来自Sangfor的10个工业客户的50多台Linux机器和250多台Window机器，NODLINK对顾客进行五天的监控，用前三天训练NODLINK和Unicorn的检测模型，用后两天进行测试。

（5）图级精确度结果

封闭世界结果
尽管Baselines可以检测所有攻击，但它们报告的误报比NODLINK更多。
ProvDetector无法在DARPA-CADET中检测到攻击，并且由于内存限制无法对DARPA-TRACE进行检测。Unicorn的图级精度较低，因为它过度逼近起源图，它将起源图投影到数值向量进行检测。这一步降低了它的图级精度。Holmes有更多的GFP，因为它的规则过于保守，可能会为长时间运行的进程生成大量误报。
开放世界结果
在开放世界实验中，NODLINK的节点级精度较低，因为开放世界实验中的信噪比要低得多。Holmes在开放世界的实验中未能检测到任何攻击，因为它的规则集缺乏检测webshells和处理劫持攻击的规则。

（6）节点级精确度结果

封闭世界结果
NODLINK的节点级精度可与离线检测系统ProvDetector相媲美。对于节点级召回，NODLINK在其报告的起源图中捕获了大部分攻击步骤。平均而言，NODLINK覆盖了98%的攻击相关事件。Holmes的节点级召回率较低，因为它缺乏检测几个攻击步骤的规则。不能测量Unicorn的节点级召回，因为它只报告起源图中的所有事件，而不管事件与攻击相关还是无关。
开放世界结果
NODLINK实现了与Unicorn相同的节点级召回，节点级准确率提高了两个数量级。

（7）效率

通过测量NODLINK的吞吐量来评估NODLINK及时检测APT攻击的效率，吞吐量的定义是每秒可以处理多少系统事件。
NODLINK在DARPATHEIA和DARPA-TRACE中具有较高的吞吐量，而Holmes在In-lab Arena数据集和开放世界的实验中具有较高的吞吐量。ProvDetector显示的吞吐量最低，因为它需要计算每个事件的规则性分数并找到K条最长路径。

（8）效率消融实验

NODLINK设计了内存缓存和ISG(重要性得分)来提高效率。实验中使用DARPA数据集分别对它们对效率的影响进行了消融研究。为了评估缓存设计，我们禁用了缓存，并将所有起源数据和缓存的图存储在图数据库Neo4j中；为了评估ISG算法，我们在每个时间窗口中使用了传统的Steiner树近似算法作为Baseline。禁用内存中缓存设计时，效率比原始设计慢82.54%-159.06倍。当用Kou替换我们的算法时，在DARPACADETS上的效率要慢8406.86倍。

（9）生产过程检测到的攻击

（10）超参数

利用在DARPA数据集上的最优实验结果来选择默认的超参数。
跳集构造的α，β和γ
α影响节点距离对异常评分的影响。在图级精度和节点级精度方面，α值为0.5-0.9时表现同样出色。β应该比γ大得多，以确定具有接近AS的节点的优先级。实验测试了(100，1)、(500，1)和(1000，1)的β和γ，在图级精度和节点级精度上得到了类似的结果。
跳集构造的θ

使用节点级准确率和节点级召回率来衡量工具在不同θ值下的影响。θ确定每个异常节点的搜索范围，影响图级和节点级的精度。θ值越高，节点级准确度越低，节点级召回率越高。将θ设置为10可确保完整报告攻击场景，同时保持可接受的精度。
衰变因子ϵ

对于衰减因子ϵ的最佳值，通过改变ϵ的值来测量假阳性和真阳性的数量。NODLINK能够检测到从0.5%到0.9%的所有设置中的所有攻击（即图级召回率为1）。实验结果还表明，当衰减因子ϵ小于0.8时，报告的误报更多。因为ϵ会影响图在缓存中保留的时间。该值越小，图被从缓存中逐出的概率就越高。因此，在我们的实验中，ϵ=0.8.

代码解读

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