DeepCoFFEA:通过度量学习和放大改进对Tor的流量关联攻击
DeepCoFFEA: Improved Flow Correlation Attacks on Tor via Metric Learning and Amplification
Name | Institution | |
---|---|---|
Se Eun Oh | Ewha Womans University | seoh@ewha.ac.kr |
Taiji Yang | University of Minnesota | yang6682@umn.edu |
Nate Mathews | Rochester Institute of Technology | njm3308@rit.edu |
James K Holland | University of Minnesota | holla556@umn.edu |
Mohammad Saidur Rahman | Rochester Institute of Technology | mr6564@rit.edu |
Nicholas Hopper | University of Minnesota | hoppernj@umn.edu |
Matthew Wright | Rochester Institute of Technology | matthew.wright@rit.edu |
来源 | 级别 | 年份 |
---|---|---|
IEEE Symposium on Security and Privacy (SP) | 信息安全顶会 | 2022 |
摘要
端到端流量关联攻击是低延迟匿名网络中最早已知的攻击之一,并被视为 Tor \text{ Tor } Tor 流量分析的核心原语( c o r e p r i m i t i v e core\ primitive core primitive)。然而,尽管最近的研究表明,单个流可以被高度准确地关联,但即便是这些最先进的攻击也存在一个核心缺陷:它们的成对性质,需要比较 N 2 \text{ N}^2 N2对流量以去匿名化 N \text{ N } N 用户。这导致计算需求的组合爆炸和渐近下降的基本速率,导致要么大量误报,要么成功关联率极低。在本文中,我们介绍了一种新颖的流量关联攻击, DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA ,它结合了两个想法以克服这些缺点。
首先,DeepCoFFEA 使用深度学习训练一对特征嵌入网络
,分别将 Tor \text{ Tor } Tor 和出口流映射到单个低维空间中,在该空间中,相关流量是相似的;嵌入流对比完整轨迹对的比较成本更低。其次, DeepCoFFEA 使用放大技术,将流量划分为短窗口,并通过这些窗口的投票显著减少误报(假阳 FP)
;相同的嵌入网络可以与越来越多的窗口一起使用,以独立降低误报率。我们进行了全面的实验分析,表明 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 在 Tor \text{ Tor } Tor 上显著优于最先进的流量关联攻击,例如,在调优为高精度时,真阳性率为 93 % 93\% 93%,而之前的工作最多只有 13 % 13\% 13%,速度提升了两个数量级。我们还考虑了几种潜在对策对 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 的影响,发现现有的轻量级防御不足以保护匿名网络免受此威胁。
I. 引言
Tor \text{ Tor } Tor 也许是最著名的匿名网络,每天有数百万人使用它 [1] 来隐藏他们的敏感互联网活动,使其不被服务器、 ISP \text{ ISP } ISP 和潜在的国家级攻击者发现。 Tor \text{ Tor } Tor 通过一系列使用分层加密的中继来路由流量,以此提供低延迟的匿名性,以防止任何单一实体仅通过其内容了解连接的源和目的地。
尽管如此,众所周知,在低延迟匿名网络中,网络与终端系统(客户端和服务器)之间发送的流量的时间和量( v o l u m e volume volume)可以用于流量分析。例如,最近将流量分析应用于 Tor \text{ Tor } Tor 的工作集中在网站指纹识别 [2]–[9],即根据客户端和入口中继之间的流量识别客户端下载了哪个网站。
也许对低延迟匿名系统最基本的流量分析攻击是端到端流量关联攻击:攻击者观察进入网络和离开网络的流量,并试图关联这些流量,从而将每个用户与可能的目的地配对。这类攻击在 Tor \text{ Tor } Tor 之前的系统设计中就已经为人所知并被讨论过,例如 Onion Routing \text{ Onion Routing } Onion Routing 网络 [10] 和 Freedom \text{ Freedom } Freedom 网络 [11]。
Tor \text{ Tor } Tor 设计 [12] 明确承认这类攻击可能有效,并集中在一个更有限的威胁模型上。反过来,许多关于 Tor \text{ Tor } Tor 安全性的已发表分析将流量关联视为核心原语,并仅计算攻击者可以观察到的流量比例 [13]–[24]。这些工作通常描述了一些方法,通过对 Tor \text{ Tor } Tor 协议的内部操作、互联网路由基础设施的操作,或网络定位和资源的结合来增加或限制攻击者可以观察到的流量比例,并假设流量关联将在这些观察中起作用。
尽管有这些假设,端到端流量关联攻击对
Tor
\text{ Tor }
Tor 网络的现实威胁程度仍不明确。直接将这些攻击应用于
Tor
\text{ Tor }
Tor 流量的一个问题是,由于各种因素,客户端和入口中继之间的流量与出口中继和目的地服务器之间的流量并不相同
:加密流量的多路复用;用于在
Tor
\text{ Tor }
Tor 节点之间传输数据的固定大小单元;以及由缓冲、拥塞、线路之间的相互作用和
Tor
\text{ Tor }
Tor 的流量控制机制引起的延迟。例如,当
Sun
\text{ Sun }
Sun 等人 [17] 将
Spearman
\text{ Spearman }
Spearman 秩相关应用于一小部分入口流(称为
Tor
\text{ Tor }
Tor 流,因为它们被包装在
Tor
\text{ Tor }
Tor 单元协议中)时,他们发现每个流量几乎需要100MB的流量才能获得足够的性能。
Nasr, Bahramali, 和 Houmansadr
\text{ Nasr, Bahramali, 和 Houmansadr }
Nasr, Bahramali, 和 Houmansadr [25] 通过使用深度神经网络(
DNNs
\text{ DNNs }
DNNs )来学习一种更有效的
Tor
\text{ Tor }
Tor 特定流量关联指标
DeepCorr
\text{ DeepCorr }
DeepCorr 解决了这一限制,该指标使用更少的流量将流对分类为相关或不相关,且精度非常高。
然而,端到端 Tor 流量关联的另一个基本限制是攻击的成对性质
。为了确定一个进入
Tor
\text{ Tor }
Tor 网络的流和一个离开它的流是否在同一个
Tor
\text{ Tor }
Tor 连接上,这些攻击计算两个流向量(由数据包时间和大小组成)之间的关联性;为了去匿名化一组流,这些攻击必须计算所有可能的进入和离开流之间的关联性。因此,要去匿名化
N
\text{ N }
N 个
Tor
\text{ Tor }
Tor 连接,它们将进行
N
2
\text{ N }^2
N 2次比较。
自然地,当给定时刻的流量数量可以达到数万时,这在计算上是非常昂贵的。或许更为关键的是,成对比较会导致较差的贝叶斯检测率( BDRs \text{ BDRs } BDRs ),因为基本率( b a s e r a t e base\ rate base rate)—— Tor \text{ Tor } Tor 连接的两端是相关的概率——非常低(即 1 N \frac{1}{ \bold N } N1)。任何具有固定误报率( FPR \text{ FPR } FPR )为 ρ \text{ ρ } ρ 的关联度量将错误地将 ρN \text{ ρN } ρN 个出口流分类为与每个入口流相关【译者注:应该是一种近似,实际上严谨的数值我认为应该为 N ( N − 1 ) 2 × ρ \frac{N(N-1)}{2}×\rho 2N(N−1)×ρ】,因此在度量将其分类为相关的情况下,给定对实际上相关的概率为 1 1 + ρ N \frac{1}{1+ρN} 1+ρN1,随着 N \text{ N } N 的增加,该概率接近于0。
本文提出了一种新方法,(i)通过使用改进的三元组网络方法 [26] 显著降低每次比较的成本,该方法首先将 Tor 流和出口流嵌入到低维空间中,然后在这些嵌入之间使用更高效的比较
;(ii) 使用放大技术 [27] 来聚合每对流的多个比较,允许显著降低 FPR ,无需学习新的嵌入或度量
。
为了更好地理解三元组网络方法的优势,注意到
DeepCorr
\text{ DeepCorr }
DeepCorr 学习的是
Tor
\text{ Tor }
Tor 和出口流特征的成对组合,因此必须对每对流量运行一个昂贵的
DNN
\text{ DNN }
DNN (成本为
N
2
\text{ N }^2
N 2次
DNN
\text{ DNN }
DNN 运行)。相比之下,我们开发特征嵌入网络来学习两种类型的嵌入
,即
Tor
\text{ Tor }
Tor 和出口流嵌入,扩展了之前在网站指纹攻击中的想法 [28]。该架构学习一对函数分别生成入口流和出口流嵌入
,并且这两个函数应用于每个流,每个流仅需两次
DNN
\text{ DNN }
DNN 评估(成本为
2
N
2N
2N 次
DNN
\text{ DNN }
DNN 运行)。然后可以在嵌入空间中使用简单的距离函数以更低成本进行成对比较
。
放大的关键优势,借鉴自随机算法 [27],来自于能够对每对流进行多次、部分独立的相关性测试。为此,我们将流分成一系列 k \text{ k } k 个短时间段或窗口。然后我们为每个流提取 k \text{ k } k 个嵌入(将我们的计算成本适度提高一个 k \text{ k } k 的因子),并逐步进行 Tor \text{ Tor } Tor 和出口流的成对比较。正确匹配的流应在几乎所有 k \text{ k } k 个窗口中都相关,而不匹配的流可能最多只在某些窗口中相关。因此,这种窗口化方法放大了真阳性( TPs \text{ TPs } TPs )和潜在误报( FPs \text{ FPs } FPs )之间的差异。
我们将这种攻击称为 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA ,即深度相关流特征提取和放大( D e e p C o r r e l a t e d F l o w F e a t u r e E x t r a c t i o n a n d A m p l i f i c a t i o n Deep\ Correlated\ Flow\ Feature\ Extraction\ and\ Amplification Deep Correlated Flow Feature Extraction and Amplification)。为了简要描述我们的攻击,网络级攻击者通过运行自己的中继或控制自治系统( ASes \text{ ASes } ASes ),监控客户端和入口守护之间的 Tor \text{ Tor } Tor 流 t i t_i ti,以及出口中继和目的地服务器之间的出口流 x j x_j xj,如图1所示。
提取数据包时间和大小信息后,攻击者共同训练两个
DNN
\text{ DNN }
DNN 模型(
G
\text{ G }
G 和
H
\text{ H }
H ),分别以
Tor
\text{ Tor }
Tor 流和出口流作为输入;
G
\text{ G }
G 和
H
\text{ H }
H 应具有这样一个属性:如果
Tor
\text{ Tor }
Tor 流
t
\text{ t }
t 和出口流
x
\text{ x }
x 相关,则对于某个关联度量
d
\text{ d }
d 和阈值
τ
\text{ τ }
τ ,
d(G(t), H(x))
≥
τ
\text{ d(G(t), H(x))} \geq \text{ τ }
d(G(t), H(x))≥ τ ,但如果它们不相关,则
d(G(t), H(x))
<
τ
\text{ d(G(t), H(x))} < \text{ τ }
d(G(t), H(x))< τ 。然后,攻击者将
G
\text{ G }
G 和
H
\text{ H }
H 应用于连续
k
\text{ k }
k 个流窗口以提取特征嵌入向量,并计算成对关联矩阵。最后,如果两个流在至少
k
−
l
\text{ k }-l
k −l 个窗口(对于一个小阈值
l
l
l )中被
d
\text{ d }
d 视为相关,则攻击者确定这些流是相关的,否则它们不是;这显著放大了
TPs
\text{ TPs }
TPs 和
FPs
\text{ FPs }
FPs 之间的差异。
尽管 DeepCorr \text{ DeepCorr } DeepCorr 和 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 都执行成对关联,但 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 效率更高,因为 G \text{ G } G 和 H \text{ H } H 生成总共 2 k N 2kN 2kN个嵌入向量,而 DeepCorr \text{ DeepCorr } DeepCorr 处理 N 2 \text{ N}^2 N2对。这是因为 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 使用便宜的距离计算比较每对流的嵌入向量,而 DeepCorr \text{ DeepCorr } DeepCorr 基于 Tor \text{ Tor } Tor 和出口流的成对信息执行昂贵的 DNN \text{ DNN } DNN 评估。
这种改进的策略使 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 能够在减少所需计算资源的同时,提高相对于 DeepCorr \text{ DeepCorr } DeepCorr 的 BDR \text{ BDR } BDR 。例如,在对1万个流进行关联分析时,对于给定的 FPR \text{ FPR } FPR ( 1 0 − 4 10^{-4} 10−4), DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 检测到的真实相关对的数量级(真阳性率为 85 % 85\% 85%对 8 % 8\% 8%, TPR \text{ TPR } TPR )显著更高,,而计算时间减少了两个数量级。我们还表明, DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 的有效性可以跨目的地、线路和时间转移;特别是, DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 能够有效地在评估集( e v a l u a t i o n d a t a s e t evaluation\ dataset evaluation dataset)中关联流,其收集时间比其训练集晚14个月。我们还表明,由于放大, DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 可以学习足够的有用特征来关联受到未知填充防御保护的流。
结合 DeepCorr \text{ DeepCorr } DeepCorr 的结果和网站指纹识别的最新进展 [5],这些结果表明迫切需要开发和部署流量分析对策以保护 Tor \text{ Tor } Tor 用户。
II. 背景
A. 流量关联攻击
我们首先在附录 A 中回顾了过去关于端到端流量关联的研究。接下来,我们讨论了最近的流量关联技术, RAPTOR \text{ RAPTOR } RAPTOR 和 DeepCorr \text{ DeepCorr } DeepCorr ,在本文中我们称之为最先进的攻击,并将其与 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 进行比较。
最先进的攻击。在最近关于对 Tor \text{ Tor } Tor 的被动关联攻击的研究中, Sun et al. \text{ Sun et al. } Sun et al. [17] 提出了 RAPTOR \text{ RAPTOR } RAPTOR 攻击,该攻击利用不对称流量分析来监控更高比例的 Tor \text{ Tor } Tor 连接的两端。他们使用 Spearman’s rank correlation \text{ Spearman’s rank correlation } Spearman’s rank correlation 算法测量了 50 50 50对流的关联性,每对流包括 300 300 300秒的流量。他们发现,先前研究的统计关联指标存在可扩展性问题,因为需要较长的流量样本才能得出可接受的结果。
针对这一问题, Nasr, Bahramali and Houmansadr \text{ Nasr, Bahramali and Houmansadr } Nasr, Bahramali and Houmansadr [25] 后来描述了一种新的流量关联指标, DeepCorr \text{ DeepCorr } DeepCorr ,它专门针对 Tor \text{ Tor } Tor 流量进行了深度学习训练。为了评估 DeepCorr \text{ DeepCorr } DeepCorr ,他们还收集了文献中出现的最大和最全面的关联流量数据集,使用不同时间段和不同电路的实时 Tor \text{ Tor } Tor 网络流量。虽然 DeepCorr \text{ DeepCorr } DeepCorr 使用仅 100 100 100个数据包的流量数据相比 RAPTOR \text{ RAPTOR } RAPTOR 实现了更高的 TPR \text{ TPR } TPR 和更低的 FPR \text{ FPR } FPR ,但其模型的 BDR \text{ BDR } BDR 较低。例如,根据我们的实验,使用 2 , 093 2,093 2,093对测试流, DeepCorr \text{ DeepCorr } DeepCorr 达到了 81.7 % 81.7\% 81.7%的 TPR \text{ TPR } TPR 和 0.16 % 0.16\% 0.16%的 FPR \text{ FPR } FPR ,然而 BDR \text{ BDR } BDR 为 19.8 % 19.8\% 19.8%。
DeepCorr 方法也存在显著的局限性,可能导致怀疑者质疑该论文的结果
。首先,使用
DeepCorr
\text{ DeepCorr }
DeepCorr 在像
Tor
\text{ Tor }
Tor 这样受欢迎的网络上进行关联攻击的计算复杂度很高,因为
DeepCorr
\text{ DeepCorr }
DeepCorr 网络通过流量对来估计其关联性,因此必须在
N × N
\text{ N × N }
N × N 对流量上进行评估。此外,由于该指标学习了在当前网络条件下预测关联流量的最佳特征,因此必须每3-4周重新训练一次。
B. 嵌入和三元组网络
Schroff et al. \text{ Schroff et al. } Schroff et al. [26] 提出了一个基于 CNNs \text{ CNNs } CNNs 的人脸识别系统,称为 FaceNet \text{ FaceNet } FaceNet 。该系统不是直接比较高维人脸图像,而是将图像映射到低维向量(我们称之为特征嵌入),以便同一个人的两张图像具有非常相似的嵌入,而不同人的图像具有较低相似度的嵌入。更具体地说, FaceNet \text{ FaceNet } FaceNet 试图训练一个具有“三元组”损失函数的 CNN \text{ CNN } CNN ,该函数应最小化同一个人的图像嵌入之间的欧几里得距离,并最大化不同人的图像嵌入之间的距离。因此,我们称这种 DNN \text{ DNN } DNN 训练模型为三元组网络。
FaceNet \text{ FaceNet } FaceNet 通过三个嵌入网络副本进行训练——称为 Anchor (A) \text{ Anchor (A) } Anchor (A) 、 Positive (P) \text{ Positive (P) } Positive (P) 和 Negative (N) \text{ Negative (N) } Negative (N) CNNs \text{ CNNs } CNNs ,这些网络共同训练并共享权重,即一个统一的嵌入。该网络的每个输入由三张图像组成: A, P \text{ A, P } A, P 和 N \text{ N } N 三元组。 A \text{ A } A 和 P \text{ P } P 始终选自同一个类别(即正对),而 A \text{ A } A 和 N \text{ N } N 选自不同的类别(即负对)。为了选择最佳的训练三元组,研究人员使用了几种三元组挖掘方法:随机( r a n d o m random random),困难负样本( h a r d − n e g a t i v e hard-negative hard−negative)和半困难负样本( s e m i − h a r d − n e g a t i v e semi-hard-negative semi−hard−negative)。困难负样本意味着与 A \text{ A } A 三元组更接近的 N \text{ N } N 三元组。
他们工作的目标函数旨在确保 A \text{ A } A 和 P \text{ P } P 嵌入之间的 L2 \text{ L2 } L2 距离与 A \text{ A } A 和 N \text{ N } N 嵌入之间的 L2 \text{ L2 } L2 距离之间存在最小间距或差距 α \text{ α } α 。即, ∣ ∣ f ( A ) − f ( P ) ∣ ∣ 2 2 + α < ∣ ∣ f ( A ) − f ( N ) ∣ ∣ 2 2 ||f(A) − f(P)||_2^2+ α < ||f(A) − f(N)||_2^2 ∣∣f(A)−f(P)∣∣22+α<∣∣f(A)−f(N)∣∣22,其中 f f f 是嵌入, α \text{ α } α 是正对(即 (A,P) \text{ (A,P) } (A,P) )和负对(即 (A,N) \text{ (A,N) } (A,N) )之间的间距( m a r g i n margin margin)。
最近, Sirinam et al. \text{ Sirinam et al. } Sirinam et al. [28] 研究了将三元组网络用于网站指纹识别,他们称之为“三元组指纹识别”( TF \text{ TF } TF )。他们使用网站轨迹嵌入之间的余弦相似度得分来计算三元组损失,并采用 DF \text{ DF } DF [5]架构作为三元组网络的子网络。在 TF \text{ TF } TF 的“攻击阶段”,他们没有直接计算嵌入对的余弦相似度得分,而是使用具有 N-shot \text{ N-shot } N-shot 学习概念的 k-NN \text{ k-NN } k-NN 分类器进行训练和测试,即用很少的训练样本来训练分类器。他们证明,使用在一组网站轨迹上训练的嵌入网络,他们能够用每类非常少的样本学习独立的轨迹集分类器,并且与使用大量训练集的 DF \text{ DF } DF 相比,达到了可比或更高的准确性。
DeepCoFFEA
\text{ DeepCoFFEA }
DeepCoFFEA 的嵌入部分受这两项以前工作的启发。我们的主要区别在于,
DeepCoFFEA
\text{ DeepCoFFEA }
DeepCoFFEA 需要学习
Tor
\text{ Tor }
Tor 和出口流的嵌入,而
TF
\text{ TF }
TF 和
FaceNet
\text{ FaceNet }
FaceNet 分别学习了统一的嵌入(网站轨迹嵌入和人脸图像嵌入)。这是因为在客户端和 Tor 入口守卫之间的流量已被大幅修改,而与服务器和 Tor 出口中继之间的流量不同
,因此我们的训练阶段包括两个独立的网络:一个始终在客户端和守卫之间的流量上运行的
Anchor
\text{ Anchor }
Anchor 网络,以及共享权重并始终在出口中继和服务器之间的流上运行的
Positive
\text{ Positive }
Positive 和
Negative
\text{ Negative }
Negative 网络(即
P/N
\text{ P/N }
P/N 网络)。为区别起见,我们称修改后的三元组网络为特征嵌入网络(
FENs
\text{ FENs }
FENs )。此外,为了流量关联而不是网站指纹识别或人脸识别,还需要进一步修改。我们在附录 B 中讨论了为特征嵌入网络架构采用的卷积神经网络(
CNNs
\text{ CNNs }
CNNs )。
与 TF \text{ TF } TF 类似,我们在三元组损失中使用余弦相似度,但不是 N-shot \text{ N-shot } N-shot 学习,我们直接计算所有流量对嵌入的余弦相似度,以分类流量对是否关联。关于我们的训练策略和 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 的网络架构的更多细节出现在第 IV 节,特别是我们在第 IV-A 节讨论了如何将 FaceNet \text{ FaceNet } FaceNet 和 TF \text{ TF } TF 训练扩展到 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 。
III. 动机
在本节中,我们将讨论为什么以及 DeepCoFFEA \text{DeepCoFFEA} DeepCoFFEA如何改进了最先进的流量关联度量。
最先进攻击中的问题
在先前关于流量关联攻击的工作中
[17]
\text{[17]}
[17],
[25]
\text{[25]}
[25],攻击者针对关联度量
d
(
t
,
x
)
d(t, x)
d(t,x),并计算每对在给定时间窗口内观察到的迹线(
t
r
a
c
e
trace
trace)的
d
(
t
i
,
x
j
)
d(t_i, x_j)
d(ti,xj);如果某个阈值
τ
\text{τ}
τ,满足
d
(
t
i
,
x
j
)
≥
τ
d(t_i, x_j) ≥ τ
d(ti,xj)≥τ,攻击者就会输出
t
i
t_i
ti和
x
j
x_j
xj是相关的流。这种方法要求攻击者在用
RAPTOR
\text{RAPTOR}
RAPTOR的情况下收集长的流序列
[17]
\text{[17]}
[17],或者在所有
n
2
n^2
n2个流对中评估一个开销昂贵
的
DNN
\text{DNN}
DNN模型,以使用
DNN
\text{DNN}
DNN分类器
[25]
\text{[25]}
[25]。
例如,在评估 RAPTOR \text{RAPTOR} RAPTOR攻击时 [17] \text{[17]} [17], Sun et al. \text{Sun et al.} Sun et al.计算了每对 50 50 50个 Tor \text{ Tor } Tor 连接的 Spearman \text{ Spearman } Spearman 等级相关系数,其中每个连接捕获了 300 300 300秒的流量,并选择具有最高系数的出口迹线作为最佳匹配的 Tor \text{Tor} Tor迹线。 DeepCorr \text{ DeepCorr } DeepCorr [25] \text{[25]} [25]训练了 CNN \text{ CNN } CNN 模型来学习一个度量 d ( t , x ) d(t, x) d(t,x),然后在测试阶段使用 5000 5000 5000个输入和输出流的所有配对计算这个度量,其中关联对的数量是 5000 5000 5000,非关联对的数量是 5000 × 4999 5000×4999 5000×4999。特别是,他们基于二维数组 F i , j = [ t i ; x j ] F_{i,j}=[t_i;x_j] Fi,j=[ti;xj]建立特征向量,其中 i , j ∈ { 1 , . . . , 5000 } i, j ∈ \{1, ..., 5000\} i,j∈{1,...,5000}并训练模型,以最小化模型输出和每对标签( 0 0 0表示不关联, 1 1 1表示关联)之间的交叉熵损失。通过这种训练方式, DeepCorr \text{ DeepCorr } DeepCorr 需要每个 Tor \text{ Tor } Tor 流和出口流特征的成对组合,导致高空间和时间复杂度。例如,我们发现, DeepCorr \text{ DeepCorr } DeepCorr 需要 5.5 5.5 5.5天才能在 Tesla P100 GPU \text{ Tesla P100 GPU } Tesla P100 GPU 上测试 10000 10000 10000个流。
此外,这种高时间复杂度限制了最大化数据以显著减少误报率的能力,这对于大规模流量分析至关重要。我们的放大技术通过每个 Tor \text{ Tor } Tor 流和每个出口流的 11 11 11次 DNN \text{ DNN } DNN 传递,保持了可管理的范围。然而,尝试将这种技术应用于 DeepCorr \text{ DeepCorr } DeepCorr 中的每个成对组合会进一步加剧计算成本。
A. 我们的方法
我们引入了一种新的关联攻击类型,该攻击解决了先前 Tor \text{Tor} Tor流量关联中计算复杂性和低 BDR \text{BDR} BDR的问题,使用了两种技术的组合:特征嵌入网络( FENs \text{FENs} FENs)和放大。
FENs \text{ FENs } FENs 与 2n \text{ 2n } 2n 对。基于输入和输出流的所有配对创建特征向量会给 DeepCorr \text{ DeepCorr } DeepCorr 的训练和测试带来大量成本。每个比较 d ( t i , x j ) d(t_i, x_j) d(ti,xj) 都必须评估 DeepCorr \text{ DeepCorr } DeepCorr 的 DNN \text{ DNN } DNN 。相比之下, DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 为 Tor \text{ Tor } Tor 流( G \text{ G } G )和出口流( H \text{ H } H )学习了一对函数。为了关联含 n n n 个流的集, DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 计算 n n n 个低维的 Tor \text{ Tor } Tor 嵌入 t i = G ( t i ) t_i = G(t_i) ti=G(ti),然后计算 n n n 个低维的出口嵌入 x j = H ( x j ) x_j = H(x_j) xj=H(xj),总共进行 2n \text{ 2n } 2n 次 DNN \text{ DNN } DNN 评估,然后仅使用这些嵌入向量执行 n 2 n^2 n2次低成本的余弦相似度计算 c o s ( t i ⋅ x j ) cos(t_i \cdot x_j) cos(ti⋅xj)。
更具体地说,
DeepCoFFEA
\text{ DeepCoFFEA }
DeepCoFFEA 联合训练了三个网络:锚点(
A
\text{A}
A),正(
P
\text{P}
P),和负(
N
\text{N}
N),其中
P
\text{P}
P 和
N
\text{N}
N 共享权重。
A
\text{A}
A使用
Tor
\text{Tor}
Tor迹线学习函数
G
\text{G}
G,而
P
\text{ P }
P 和
N
\text{ N }
N 根据出口迹线学习函数
H
\text{ H }
H 。如果我们有两个流对(
t
1
,
x
1
t_1, x_1
t1,x1)和(
t
2
,
x
2
t_2, x_2
t2,x2),可能的
A
\text{ A }
A ,
P
\text{ P }
P 和
N
\text{ N }
N 三元组(
a
,
p
,
n
a, p, n
a,p,n)将是(
t
1
,
x
1
,
x
2
t_1, x_1, x_2
t1,x1,x2)或(
t
2
,
x
2
,
x
1
t_2, x_2, x_1
t2,x2,x1)。如该示例所示,
x
1
x_1
x1 和
x
2
x_2
x2 都 (
b
o
t
h
both
both )出现在
P
\text{ P }
P 和
N
\text{ N }
N 网络中,这会对训练产生负面影响。因此,我们实现了一个修改后的三元组生成器,详细内容见第
IV-A
\text{IV-A}
IV-A节。最终,使用三元组损失, DeepCoFFEA 训练这些嵌入网络,最大化 a 和 p 之间的相似性,同时最小化 a 和 n 之间的相似性(即最大化差异)
。
因此,即使 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 计算 n 2 n^2 n2 个嵌入的成对余弦相似度,它只需要评估 2 n 2n 2n 个 FENs \text{ FENs } FENs 。这显著降低了关联攻击的复杂性,因为嵌入对之间的低维余弦相似度计算比全流对上的深度 CNN \text{ CNN } CNN 计算要便宜得多。
与 CTA \text{CTA} CTA的比较。使用降维来提高流量关联效率也是压缩流量分析( Compressive Traffic Analysis CTA \text{ Compressive Traffic Analysis CTA } Compressive Traffic Analysis CTA )[29]的一个核心思想。为了有效地关联受到网络噪声扰动的流,而不是通过 Tor \text{ Tor } Tor 路由, Nasr, Houmansadr \text{ Nasr, Houmansadr } Nasr, Houmansadr 和 Mazumdar \text{ Mazumdar } Mazumdar 应用高斯随机投影算法将 IPD \text{ IPD } IPD 特征向量压缩成固定维度的余弦相似嵌入,然后使用局部敏感哈希( LSH \text{ LSH } LSH )进一步降低成对关联成本。对于 N \text{ N } N 个具有 L \text{ L } L 个包的流,传感基矩阵 Φ F × L Φ_{F × L} ΦF×L(其中 F < L F < L F<L,导致 F F F维特征向量),将时间和空间复杂性减少了 L F \frac{L}{F} FL倍。此外,他们通过 LSH \text{LSH} LSH扩展了 CTA \text{CTA} CTA,避免比较一些嵌入对,将比较成本从 O ( N 2 F ) O(N^2F) O(N2F) 减少到 O ( N 1 + q F ) O(N^{1+q}F) O(N1+qF) ,其中 1 + q < 2 \text{1 + q < 2} 1 + q < 2。
FENs \text{FENs} FENs也生成低维的特征嵌入向量,减少了一个 L \text{L} L倍的复杂性。请注意,我们在第 V-C \text{V-C} V-C节中经验选择了 F \text{F} F。我们注意到,可以将 DeepCoFFEA \text{DeepCoFFEA} DeepCoFFEA扩展为应用一个适应的 LSH \text{LSH} LSH版本,以避免一些嵌入对之间的比较,但我们将这留待未来工作中。
我们在表 I \text{I} I中总结了 CTA \text{CTA} CTA, DeepCorr \text{DeepCorr} DeepCorr和 DeepCoFFEA \text{DeepCoFFEA} DeepCoFFEA的复杂性比较。
在第
VI-C
\text{VI-C}
VI-C节中,我们还评估了使用
Nasr, Houmansadr
\text{Nasr, Houmansadr}
Nasr, Houmansadr和
Mazumdar
\text{Mazumdar}
Mazumdar的实现
[29]
\text{[29]}
[29]的
CTA
\text{CTA}
CTA(没有
LSH
\text{LSH}
LSH,因此我们最大化给定误报率
FPR
\text{ FPR }
FPR 的
TPR
\text{ TPR }
TPR )的准确性,并显示在应用于
Tor/Exit
\text{ Tor/Exit }
Tor/Exit 流对时,
CTA
\text{ CTA }
CTA 未能产生有用的关联结果。
放大。为了减少误报 FPs \text{ FPs } FPs 数量,我们从随机化算法中采用了放大的概念 [27] \text{[27]} [27],其中具有任何显著接受概率差异的随机化决策过程可以重复多次,以创建一个具有指数级小误报率和漏报率的决策过程。在 DeepCoFFEA \text{DeepCoFFEA} DeepCoFFEA的上下文中,我们通过窗口分区应用放大技术,将流分成几个较小的部分重叠的子流(窗口)。然后,我们分别评估每个窗口,并以投票的方式聚合结果。
通过将 t t t 和 x x x 分成 k k k 个离散窗口,并在每个窗口的子流上计算 G \text{ G } G 和 H \text{ H } H 之间的相似度,我们最终得到 k k k 维向量,如果子流相关则为 1 1 1,否则为 0 0 0。这些是来自 k k k 个窗口的投票,然后我们聚合这些投票以确定最终决策:如果至少有 k − l k − l k−l 票为正,则流相关,否则不相关。例如,如果 k = 5 k = 5 k=5 且 l = 1 l = 1 l=1,且某个流对的投票为 [1,1,1,0,1] \text{[1,1,1,0,1]} [1,1,1,0,1],则该对被预测为相关。通过调整 k k k 和 l l l 以适应给定的预期流量集大小 n n n ,我们可以将误报率推低到 1 n \frac{1}{n} n1 的基本率以下,从而获得不趋向于 0 0 0 的 BDR \text{ BDR } BDR 。
与 DeepCorr \text{DeepCorr} DeepCorr[25]相比,攻击者不是学习比较度量 d ( t , x ) d(t, x) d(t,x),而是对每个 Tor \text{ Tor } Tor 迹线计算 G ( t ) G(t) G(t),对每个出口迹线在连续的窗口内计算 H ( x ) H(x) H(x)。我们期望只有一个出口迹线 x j x_j xj与同一 Tor \text{ Tor } Tor 迹线 t i t_i ti 至少有 k − l k−l k−l 个投票匹配。在第 VI-C \text{ VI-C } VI-C 节中,我们展示了放大可以显著减少对成对余弦相似度计算的误报数量,从而使 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 比最先进的关联技术具有更低的误报率和更高的 BDR \text{ BDR } BDR 。
此外,我们的模型不是基于标签学习的;相反,它们学习相关和不相关流对之间的统计差异,从而实现更有效的特征提取以及更广泛的模型。值得注意的是,我们在第 VI-B \text{ VI-B } VI-B 节中的实证研究展示了 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 对基于填充的防御的鲁棒性。
IV.
DEEPCOFFEA
\text{ DEEPCOFFEA }
DEEPCOFFEA 攻击
在本节中,首先,我们详细说明了如何扩展先前的工作[26], [28],训练 DeepCoFFEA FENs \text{ DeepCoFFEA FENs } DeepCoFFEA FENs 生成 Tor \text{ Tor } Tor 和出口流嵌入。接下来,我们描述了几种计算两个嵌入向量是否相关的方法,并讨论了 DeepCoFFEA FENs \text{ DeepCoFFEA FENs } DeepCoFFEA FENs 的架构和涉及的超参数。
A. 用于关联研究的特征嵌入网络
为了开发用于 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 攻击的 FENs \text{ FENs } FENs ,我们从 TF \text{ TF } TF 网络架构[28]开始,并对其进行调整以适应流量关联攻击模型。作为初步步骤,我们尝试直接使用他们的网络(即,让 A \text{ A } A , P \text{ P } P 和 N \text{ N } N 网络共享权重)在 Tor \text{ Tor } Tor 流、出口流和出口流三元组上训练,但正如预期的那样,我们发现三元组损失在训练过程中没有减少。然后我们做了以下关键更改来改进这一初步结果。
两个不同的网络。使用 TF \text{ TF } TF 架构,三元组损失没有收敛,原因有两个。首先, Tor \text{ Tor } Tor 和出口流是在不同点收集的不同流量,其中 Tor \text{ Tor } Tor 迹线是在客户端和守卫节点之间收集的,而出口流量是在出口中继和网页服务器之间收集的。其次, Tor \text{ Tor } Tor 迹线在每个窗口中的数据包数量相对较少,需要两个网络的输入维度不同。因此,与 FaceNet \text{ FaceNet } FaceNet [26]和 TF \text{ TF } TF 不同,我们采用了两个独立的模型:一个用于 A \text{ A } A 网络,另一个用于 P \text{ P } P 和 N \text{ N } N 网络的通用模型。这种方法减少了初始损失值,并进一步帮助实现了随训练而下降的损失曲线。然而,我们仍然只在训练损失上取得了较小的下降。为了进一步改进,我们修改了三元组生成器,如下所述。
三元组 Epoch 生成器( T r i p l e t E p o c h G e n e r a t o r Triplet\ Epoch\ Generator Triplet Epoch Generator)。 TF \text{ TF } TF 实现从正例和反例中选择三元组,而不考虑特定的负例是否已经在先前的输入中使用过,这导致许多出口流既被选择为正例 p \text{ p } p ,也被选择为反例 n \text{ n } n 。这迅速使三元组损失冻结在某个值,因为某些流对被交替用于最大化和最小化三元组损失函数中的关联。为了解决这个问题,我们将出口流分为两组,并实现了三元组生成器,从一组中选择 p \text{ p } p ,从另一组中选择 n \text{ n } n 。这样,我们确保在一个批次内 p \text{ p } p 和 n \text{ n } n 总是不同的。然而,我们发现,当这种保证扩展到一个 e p o c h epoch epoch 时,可以获得更好的损失曲线。注意,我们在所有实验中将一个 e p o c h epoch epoch 设置为 128 128 128个批次。因此,我们不断打乱出口迹线集,并在每个 e p o c h epoch epoch将其分成两个独立的池。通过这种 e p o c h epoch epoch 生成器,我们能够达到接近零的训练损失值。
损失函数。
DeepCoFFEA FENs
\text{ DeepCoFFEA FENs }
DeepCoFFEA FENs 被训练以最小化以下三元组损失函数:
max
(
0
,
c
o
r
r
(
G
(
a
)
,
H
(
n
)
)
−
c
o
r
r
(
G
(
a
)
,
H
(
p
)
)
+
α
)
\max(0, corr(G(a), H(n)) - corr(G(a), H(p)) + \alpha)
max(0,corr(G(a),H(n))−corr(G(a),H(p))+α)
换句话说,
FENs
\text{ FENs }
FENs 的目标是学习满足
c
o
r
r
(
G
(
a
)
,
H
(
n
)
)
+
α
<
c
o
r
r
(
G
(
a
)
,
H
(
p
)
)
corr(G(a), H(n)) + \alpha < corr(G(a), H(p))
corr(G(a),H(n))+α<corr(G(a),H(p))的嵌入
G
G
G 和
H
H
H。“负”三元组
n
\text{ n }
n 在训练
FENs
\text{ FENs }
FENs 中起着重要作用,因为在当前网络参数下我们已经有
c
o
r
r
(
G
(
a
)
,
H
(
n
)
)
+
α
<
c
o
r
r
(
G
(
a
)
,
H
(
p
)
)
corr(G(a), H(n)) + \alpha < corr(G(a), H(p))
corr(G(a),H(n))+α<corr(G(a),H(p))的“容易(
e
a
s
y
easy
easy)”负例将不会对损失做出贡献,而
c
o
r
r
(
G
(
a
)
,
H
(
p
)
)
<
c
o
r
r
(
G
(
a
)
,
H
(
n
)
)
corr(G(a), H(p)) < corr(G(a), H(n))
corr(G(a),H(p))<corr(G(a),H(n))的“难(
h
a
r
d
hard
hard)”负例将总是导致正损失。因此,我们使用“半难(
s
e
m
i
−
h
a
r
d
semi-hard
semi−hard)”负例,其中
c
o
r
r
(
G
(
a
)
,
H
(
n
)
)
<
c
o
r
r
(
G
(
a
)
,
H
(
p
)
)
+
α
corr(G(a), H(n)) < corr(G(a), H(p)) + \alpha
corr(G(a),H(n))<corr(G(a),H(p))+α。即,半难负例“足够难(
h
a
r
d
e
n
o
u
g
h
hard enough
hardenough)”,以至于它们对损失做出贡献,但“足够容易(
e
a
s
y
e
n
o
u
g
h
easy enough
easyenough)”,通过调整参数可以将损失推到零。因此,通过调整
α
\alpha
α,我们可以调整正负对之间强制执行的边距。在下一节中,我们描述了如何选择余弦相似度作为关联度量(即,
c
o
r
r
corr
corr);我们通过超参数调整选择
α
\alpha
α,如第V-C节所述。
B. 关联方法
基于
G
G
G 和
H
H
H ,我们提取
Tor
\text{ Tor }
Tor 和出口流嵌入,
G
(
t
i
,
w
)
G(t_{i,w})
G(ti,w)和
H
(
x
i
,
w
)
H(x_{i,w})
H(xi,w),其中
t
i
t_i
ti 是
Tor
\text{ Tor }
Tor 流,而
x
i
x_i
xi 是出口流,
f
i
,
w
f_{i,w}
fi,w是流
f
i
f_i
fi的第
w
w
w个窗口,并且
0
≤
i
<
n
0 \leq i < n
0≤i<n,
1
≤
w
≤
k
1 \leq w \leq k
1≤w≤k,其中,
n
n
n 为流数和
k
k
k 为窗口数。然后,我们计算
每个
0
≤
i
,
j
<
n
0 \leq i, j < n
0≤i,j<n和每个窗口
w
∈
1
,
.
.
.
,
k
w \in 1, . . . , k
w∈1,...,k的关联值
d
(
G
(
t
i
,
w
)
,
H
(
x
j
,
w
)
)
d(G(t_{i,w}), H(x_{j,w}))
d(G(ti,w),H(xj,w)) ,对于每个
n
2
n^2
n2 个潜在的流配对。第三,基于这些关联值,如果
d
(
G
(
t
i
,
w
)
,
H
(
x
j
,
w
)
)
d(G(t_{i,w}), H(x_{j,w}))
d(G(ti,w),H(xj,w))足够高,我们记录
一个
1
1
1 票,否则为
0
0
0 票。最后,我们决定
t
t
t和
x
x
x是否相关,如果它们至少收到
k
−
ℓ
k - \ell
k−ℓ个
1
1
1票。我们考虑了三种不同的计算这些相似性“票”的方法:
softmax
\text{ softmax }
softmax 函数,
k-NN
\text{ k-NN }
k-NN 分类器和余弦相似度。在本节中,我们描述这些选项。
Softmax。我们应用 softmax \text{softmax} softmax函数,它将嵌入正则化为一个向量,该向量遵循概率分布,总和为1,来处理特征嵌入。基于这个概率向量,我们可以通过取具有最高概率的对数来确定预测的“标签”。为了研究 Tor \text{ Tor } Tor 和出口流对( t, x \text{t, x} t, x),我们基于 argsort(soft(G(t))) \text{ argsort(soft(G(t))) } argsort(soft(G(t))) 和 argsort(soft(H(x))) \text{ argsort(soft(H(x))) } argsort(soft(H(x))) 计算 t \text{t} t 和 x \text{x} x 的前 h \text{h} h 个标签,其中 soft ( x i ) = e x i ∑ j = 1 n e x j \text{soft}(x_i) = \frac{e^{x_i}}{\sum_{j=1}^n e^{x_j}} soft(xi)=∑j=1nexjexi 。如果匹配的流出现在前几个标签中,我们认为它可能是相关的流。通过将 h \text{h} h从 2 2 2到 31 31 31变化,我们绘制出 TPR \text{TPR} TPR与 FPR \text{FPR} FPR的关系。
结合聚类的k近邻算法。我们使用 Tor \text{ Tor } Tor 流训练 k-NN \text{ k-NN } k-NN 分类器,并使用出口流测试它们。我们进一步使用出口流训练分类器,并使用 Tor \text{ Tor } Tor 流测试它们,以找到最佳设置。对于任一方向,我们首先必须在训练之前标记训练集中的流。我们探索了 k-means \text{k-means} k-means[30]和 Spectral clustering \text{ Spectral clustering } Spectral clustering [31]来标记训练流。对于所有聚类,我们将 k \text{k} k从 2 2 2变为 295 295 295,导出需要训练的 2 2 2到 295 295 295个标签。在使用聚类标记的 Tor \text{ Tor } Tor (或出口)流训练 k-NN \text{ k-NN } k-NN 模型后,我们使用出口(或 Tor \text{ Tor } Tor )流评估模型。然后我们对出口流的预测标签和聚类算法决定的 Tor \text{ Tor } Tor 流的标签进行成对比较。如果标签在相关流中相同,则为 TP \text{TP} TP。如果标签在不相关流中相同,则为 FP \text{FP} FP。根据初步实验,我们决定使用 Tor \text{ Tor } Tor 流训练 k-NN \text{k-NN} k-NN模型,并进一步使用出口流测试它们。我们还凭经验选择了具有余弦相似度的 Spectral clustering \text{ Spectral clustering } Spectral clustering 来标记 Tor \text{ Tor } Tor 流,并在不同的 k \text{k} k(从 2 2 2到 295 295 295)下计算 TPR \text{TPR} TPR和 FPR \text{FPR} FPR。
余弦相似度。余弦相似度测量投射在多维空间中两个向量之间角度的余弦值。它捕捉的是角度,而不是欧几里得距离之类的大小。由于 FENs \text{ FENs } FENs 是基于余弦相似度( cos \text{cos} cos)的三元组损失训练的,我们自然地研究了这种相似度得分作为 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 的相似度度量。也就是说,我们计算了所有 Tor \text{ Tor } Tor 和出口嵌入对( t i , w t_{i,w} ti,w, x j , w x_{j,w} xj,w)的每个窗口 w \text{w} w的相似度得分,其中,对于 n \text{n} n个测试流对, 0 ≤ i , j < n 0 \leq i, j < n 0≤i,j<n。对于每一对,如果 c o s ( G ( t i , w ) , H ( x j , w ) ) ≥ τ cos(G(t_i,w), H(x_j,w)) \geq \tau cos(G(ti,w),H(xj,w))≥τ对于某个阈值 τ \tau τ,我们记录1票,否则为0票。通过改变 τ \tau τ,我们绘制出 ROC \text{ ROC } ROC 图。我们在第 V-E 节中展示了如何选择 τ \tau τ。
如图2所示,余弦相似度方法优于其他方法。
余弦相似度显然更有效地区分相关流和不相关流,而基于 softmax \text{softmax} softmax的区分和聚类没有提取出有效的关联标签。在整篇论文的评估中,我们采用了余弦相似度。
C.
FEN
\text{FEN}
FEN架构
如先前的工作所示[5], [6], [25],
CNNs
\text{CNNs}
CNNs通常学习到更有用的特征来分析
Tor
\text{ Tor }
Tor 流量。因此,我们进一步探索了两种不同的架构,一种基于一维卷积(
Conv
\text{Conv}
Conv)层,另一种基于二维
Conv
\text{Conv}
Conv层。我们采用了
DF
\text{DF}
DF[5]和
DeepCorr
\text{DeepCorr}
DeepCorr[25]架构,因为它们在生成基于客户端和守卫节点之间迹线的网站指纹和基于进入和流出
Tor
\text{ Tor }
Tor 网络的流量关联特征方面非常有效。我们凭经验得出结论,基于一维 $CNN$ 的 $DF$ 架构表现更好
;更具体地说,我们无法用
DeepCorr
\text{DeepCorr}
DeepCorr架构将三元组损失减少到0.01以下。
如图3所示,两个 FEN \text{FEN} FEN模型被学习,在测试阶段, A \text{ A } A 网络将 Tor \text{ Tor } Tor 流的输入映射到特征嵌入向量,而 P/N \text{P/N} P/N网络将出口流的输入映射到特征嵌入向量。
每个
FEN
\text{FEN}
FEN包括四个一维
Conv
\text{Conv}
Conv块(
C
o
n
v
b
l
o
c
k
s
Conv\ blocks
Conv blocks),包括两个一维
Conv
\text{Conv}
Conv层,随后是一个最大池化层。之后是一个全连接输出层,它生成特征嵌入。我们基于参数优化选择了输入和输出维度、优化器和学习率,如表II所示。
最后,我们在图3中概述了一个
DeepCoFFEA
\text{ DeepCoFFEA }
DeepCoFFEA 评估示例。
V.
DEEPCOFFEA
\text{ DEEPCOFFEA }
DEEPCOFFEA 实验详情
在本节中,我们详细介绍了实验设置,包括数据集、特征、窗口分区、超参数优化以及第VI节中评估 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 的指标。
A. 输入预处理
数据收集。 据我们所知,Nasr, Bahramali 和 Houmansadr [25] 收集了在 Tor \text{ Tor } Tor 网络上收集的最全面的流量关联数据集,并反映了训练和测试数据之间不同电路使用和时间间隔的影响。我们重新解析了 DeepCorr \text{ DeepCorr } DeepCorr 集的原始捕获数据,而不是使用出站和入站的数据包是分开的预处理的数据。我们有选择地选择了流对,以确保所有连接目的地都是唯一的,最终得到 12 , 503 12,503 12,503 对流对。我们称这个集合为 DeepCorr \text{ DeepCorr } DeepCorr 数据集。
然而,我们有兴趣评估一些仅靠该数据集无法解决的附加场景,包括超过三个月的训练/测试间隔、训练和测试集没有共同电路的情况,以及测试具有大规模非训练集的能力。因此,我们收集了自己的数据集( DCF 集),模仿了 DeepCorr 的收集方法,但有一些小的不同
。
首先
,我们使用物理机器运行
Tor
\text{ Tor }
Tor 客户端和
SOCKS
\text{ SOCKS }
SOCKS 代理服务器来收集出口流,而原方法是在
VMs
\text{ VMs }
VMs 中运行客户端。其次
,我们使用
1
,
051
1,051
1,051 批次爬取了
60
,
084
60,084
60,084 个
Alexa
\text{ Alexa }
Alexa 网站,每批会重建电路。我们每个样本捕获完整
60
60
60 秒,以确保捕获包括初始页面加载后的任何动态内容。
第三
,我们在
Ethernet
\text{ Ethernet }
Ethernet 层捕获数据包,而
DeepCorr
\text{ DeepCorr }
DeepCorr 在
IP
\text{ IP }
IP 层收集。这一变化旨在去除
DeepCorr
\text{ DeepCorr }
DeepCorr 集中出现的超过
MTU
\text{ MTU }
MTU 大小的数据包,更好地模拟在线路上看到的流量。为了在数据集之间提供可移植性,我们在训练模型时将具有
IPD
\text{IPD}
IPD 值为
0
0
0 的相邻数据包组合在一起(例如,数据包在同一时刻到达/发送)。最后
,我们过滤掉了数据包计数少于
70
70
70 的流,这比
DeepCorr
\text{ DeepCorr }
DeepCorr 评估模型对
300
300
300、
400
400
400 和
500
500
500 数据包的跟踪时应用的
300
300
300、
400
400
400 和
500
500
500 要短。这样,
DCF
\text{ DCF }
DCF 集比
DeepCorr
\text{ DeepCorr }
DeepCorr 集导致更多的流被填充或截断。如附录 D 中的图 11 所示,我们探索了各种过滤器以去除长度低于
70
70
70、
300
300
300 和
500
500
500 的短流,
DeepCoFFEA
\text{ DeepCoFFEA }
DeepCoFFEA 的性能未受到过滤器大小的显著影响。
在 60 , 084 60,084 60,084 对流对中,我们选择了每窗口数据包数大于 10 10 10 的对,总共得到 42 , 489 42,489 42,489 对。请注意,为了展示模型在不同电路和站点之间的可移植性,所有 42 , 489 42,489 42,489 个连接都涉及唯一的目的地。这确保了训练和测试集之间不存在重叠的目的地和电路使用。
此外,我们还使用 obfs4 Pluggable Transport \text{ obfs4 Pluggable Transport } obfs4 Pluggable Transport 收集了 13 , 000 13,000 13,000 个流,用于评估对抗防御流的效果。我们还捕获了一些在 2020 年 4 月爬取的旧流,用于评估训练和测试数据之间存在长时间间隔的实验场景。
为了进一步评估 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 对轻量级网站指纹防御(包括 WTF-PAD \text{ WTF-PAD } WTF-PAD [32] 和 FRONT \text{ FRONT } FRONT [33])的表现,我们还使用研究人员共享的官方实现模拟了防御流 [34], [35]。
窗口池化。 DeepCorr \text{DeepCorr} DeepCorr 的 n n n 对相关流量对可以用于创建最多 n 2 n^2 n2 个输入对,在 DeepCoFFEA \text{DeepCoFFEA} DeepCoFFEA 中,每对相关流量对最多只能生成一个三元组,从而为 FEN \text{FEN} FEN 模型创建的训练示例要少得多。我们通过三元组挖掘选择一个更有用的半难负例,而不是将所有可能的对都输入 FENs \text{ FENs } FENs 。例如,如果我们有三对流,( t 1 , x 1 t_1,x_1 t1,x1),( t 2 , x 2 t_2,x_2 t2,x2),和( t 3 , x 3 t_3,x_3 t3,x3),我们的方法生成的输入对是 [ ( t 1 , x 1 , x 2 ) , ( t 2 , x 2 , x 1 ) , ( t 3 , x 3 , x 2 ) ] [(t_1,x_1,x_2),(t_2,x_2,x_1),(t_3,x_3,x_2)] [(t1,x1,x2),(t2,x2,x1),(t3,x3,x2)]。根据我们的周期生成器,只有第一个和第三个三元组可以出现在同一个周期中。
通过将流分成 k k k 个窗口,我们能够跨窗口池化关联对,使 FEN \text{ FEN } FEN 训练集大小增加了 k k k 倍。更具体地说,我们根据调优期间选择的预定义时间间隔划分每个流,并构建训练集。基于 10 , 000 10,000 10,000 对训练流,我们使用所有 k k k 个流窗口构建了训练集,从而得到 k ⋅ 10 , 000 k ·10,000 k⋅10,000 个关联流对。相反,我们为每个窗口分别构建了 k k k 个测试集,其中有 n n n 对( 2094 ≤ n ≤ 10 , 000 2094 ≤ n ≤ 10,000 2094≤n≤10,000)。因此,该设置导致在 k k k 个窗口中使用 n n n 个 Tor \text{ Tor } Tor 和出口流对测试 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 。我们在第V节 B 部分详细介绍了窗口分区。
特征。与 DeepCorr \text{ DeepCorr } DeepCorr [25] 一样,我们使用数据包间延迟( IPD \text{IPD} IPD)和数据包大小信息从流中构建特征向量。由于我们为 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 选择了 1D \text{1D} 1D CNN \text{ CNN } CNN 模型,我们通过连接 IPD \text{IPD} IPD 和数据包大小的向量来构建一维数组, v i = [ I i ∣ ∣ S i ] v_i = [I_i ||S_i] vi=[Ii∣∣Si],用于双向的 Tor \text{ Tor } Tor 和出口流。这里,向量 I i I_i Ii 由上行 IPD \text{IPD} IPD( I u I^u Iu)和下行 IPD \text{IPD} IPD( − I d -I^d −Id)组成,向量 S i S_i Si 由上行数据包大小( S u S^u Su)和下行数据包大小( − S d -S^d −Sd)组成。
我们还基于其他组合评估了 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA ,例如 v i = [ I i u ∣ ∣ S i u ∣ ∣ I i d ∣ ∣ S i d ] v_i = [I^u_i ||S^u_i ||I^d_i ||S^d_i] vi=[Iiu∣∣Siu∣∣Iid∣∣Sid] 或 [ I i u ∣ ∣ I i d ∣ ∣ S i u ∣ ∣ S i d ] [I^u_i ||I^d_i ||S^u_i ||S^d_i] [Iiu∣∣Iid∣∣Siu∣∣Sid],这些特征向量导致性能更差,可能是因为上下行流量的局部交织允许(局部) CNN \text{ CNN } CNN 过滤器提取更相关的特征。同样,我们尝试基于仅使用 IPD \text{IPD} IPD 向量或数据包大小向量的特征集训练 FENs \text{ FENs } FENs ,发现这些效果也较差。
最后,我们仅使用数据包大小特征评估了 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 。在考虑数据包时间和大小信息时,相关流对之间的余弦相似度得分更高,这表明 IPD \text{IPD} IPD 序列为相关流提供了信息丰富的特征。
B. 窗口划分
我们测试了两种划分策略,一种基于时间间隔,另一种基于数据包数量,然后决定使用时间间隔作为窗口间隔,因为它产生了更好的三元组损失曲线
。这是因为
Tor
\text{ Tor }
Tor 流在每个时间段内的数据包数量通常少于出口流,所以当使用基于固定数量数据包的窗口时,第二个及以后的窗口流不再对应于相同的流量。我们在第V-C节中根据经验确定了窗口数量和间隔。
我们进一步探索了重叠窗口划分,创建了在后续窗口之间具有某些间隔重叠( δ \delta δ)的重叠窗口,我们称之为 δ − o n \delta-on δ−on 划分。如图4所示,当窗口间隔长度为 t t t 且总流量持续时间为 d d d 时, δ − o f f \delta-off δ−off 划分导致 ⌊ d − t t ⌋ + 1 \left\lfloor \frac{d-t}{t} \right\rfloor + 1 ⌊td−t⌋+1个间隔,其中窗口 w w w是间隔 [ t × w , t × w + t ) [t \times w, t \times w + t) [t×w,t×w+t)。相比之下, δ − o n \delta-on δ−on 导致 ⌈ d − t t − δ ⌉ + 1 \left\lceil \frac{d-t}{t-\delta} \right\rceil +1 ⌈t−δd−t⌉+1个间隔,其中窗口 w w w 是间隔 [ ( t − δ ) × w , ( t − δ ) × w + t ) [(t - \delta) \times w, (t - \delta) \times w + t) [(t−δ)×w,(t−δ)×w+t)。例如,当 t = 5 , d = 25 , δ = 3 t = 5, d = 25, \delta = 3 t=5,d=25,δ=3时, 5 5 5个 δ − o f f \delta-off δ−off 窗口是间隔 [ 0 , 5 ) [0,5) [0,5)、 [ 5 , 10 ) [5,10) [5,10)、…、 [ 20 , 25 ) [20,25) [20,25),而 11 11 11个 δ − o n \delta-on δ−on 窗口是间隔 [ 0 , 5 ) [0,5) [0,5)、 [ 2 , 7 ) [2,7) [2,7)、…、 [ 20 , 25 ) [20,25) [20,25)。因此,使用 δ − o n \delta-on δ−on ,我们创建了更多的窗口,导致更多的训练流对,并通过聚合更多窗口的结果增加了 TP \text{TP} TP和 FP \text{FP} FP的差异。换句话说, δ − o n \delta-on δ−on 增加了 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 的放大效果,如第VI-B节所示显著提高了性能。
C. 超参数优化
超参数的选择对于提高 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 的性能尤其是 FENs \text{ FENs } FENs 的行为至关重要,从而导致更低的三元组损失。因此,我们使用一台 Nvidia RTX 2080 \text{ Nvidia RTX 2080 } Nvidia RTX 2080 和一台 Tesla P100 GPU \text{ Tesla P100 GPU } Tesla P100 GPU 探索了表II中显示的参数搜索空间。尽管我们使用 DCF \text{ DCF } DCF 集来调整这些参数,但我们注意到在选择这些参数时, DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 的性能对数据集并不是非常敏感。一个例外是输入维度;每个窗口的流量速率可能会有显著变化,因此,虽然本节中的其他参数可以在不进一步搜索的情况下使用,但输入维度应根据新的网络条件进行调整。这里我们详细说明了如何选择参数范围。
窗口设置参数。 FENs \text{ FENs } FENs 的流输入长度应在可接受的训练成本范围内优化模型性能。
我们首先调查了第一个窗口间隔的最短持续时间,其中位数数据包数为 100 100 100 个数据包。注意, DeepCorr \text{ DeepCorr } DeepCorr 选择了 100 100 100 个数据包作为他们探索的最短流长度[25]。在附录C的表VI中计算了 2 2 2 到 5 5 5 秒间隔的中位数数据包数后,我们确定五秒会给出最佳性能。
此外,我们将总流量持续时间的搜索空间设置为最多 35 35 35 秒,因为如附录C的表VII所示,35秒后的窗口数据包数变得少于 100 100 100 个数据包。其次,在 δ = 0 \delta = 0 δ=0 的情况下,我们探索了各种总流量持续时间,因为 DCF \text{ DCF } DCF 性能在 25 25 25 秒后开始下降。第三,根据附录C的表VIII,我们使用 11 11 11 个窗口的最小和最大流长度作为 Tor \text{ Tor } Tor 流长度和出口流长度的搜索空间,分别为Tor 流的[106,501]和出口流的[244,855]。
窗口划分参数。 首先,我们研究了不同 δ \delta δ 的 δ − o n / o f f \delta-on/off δ−on/off 设置的影响。如第V-B节所述, δ \delta δ-on创建 ⌈ 25 − 5 5 − δ ⌉ + 1 \left\lceil \frac{25-5}{5-\delta} \right\rceil + 1 ⌈5−δ25−5⌉+1 个窗口,即, δ = 1 \delta = 1 δ=1 时创建 6 6 6 个窗口, δ = 2 \delta = 2 δ=2 时创建 8 8 8 个窗口, δ = 3 \delta = 3 δ=3 时创建 11 11 11 个窗口。注意,我们省略了 δ = 4 \delta = 4 δ=4,因为 21 21 21 个窗口导致 218 , 610 218,610 218,610 个训练流对的余弦相似度矩阵太大,无法使用我们的资源计算,因此我们无法选择半难负例。我们在图5a中报告了 3 − o n 3-on 3−on、 2 − o n 2-on 2−on 和 1 − o n 1-on 1−on设置的 ℓ = 2 \ell = 2 ℓ=2 和 ℓ = 1 \ell = 1 ℓ=1 的结果。尽管 δ = 1 \delta = 1 δ=1 未能改善 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 性能,但随着 δ \delta δ 的增加, DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 受益于增强的放大能力,通过更多的训练流对和更多的投票结果。图5a显示,较大的 δ \delta δ通常会通过使用更多投票得到更好的 ROC \text{ ROC } ROC 曲线,具有更高的 TPR \text{ TPR } TPR ,表明资源更丰富的攻击者可以通过使用 4 − o n 4-on 4−on 设置进一步改善 3 − o n 3-on 3−on 的结果。根据图5a中显示的结果,我们在第VI节中评估了 3 − o n 3-on 3−on 设置下的 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 。
模型参数。 由于三元组损失旨在通过距离边距 α \alpha α 将正对与负对分开,我们首先调整 α \alpha α 以最大化相关对的余弦相似度得分与不相关对的余弦相似度得分之间的差异。使用 α = 0.1 \alpha=0.1 α=0.1 时, FENs \text{ FENs } FENs 达到了最低损失,我们注意到 TF \text{ TF } TF [28]也使用了相同的值。其次,如第IV-A节所述,我们实现了自己的三元组时期生成器,从独立池中为正负网络选择三元组。我们进一步调整了这些独立池需要更新的频率(即,洗牌并分为两个池)。最终,当更频繁地更新池时, FEN \text{ FEN } FEN 性能得到了改善。因此,我们建议每个 e p o c h epoch epoch 而不是每 2 − 10 2-10 2−10 个 e p o c h epoch epoch 更新它们。
最后,我们进一步调整了 SGD \text{ SGD } SGD 优化的学习率和输出节点的数量,这是由训练的 FENs \text{ FENs } FENs 生成的特征嵌入的维度。
关联参数。 我们必须决定在三元组损失函数中计算的关联度量,因此我们探索了前期研究提出的余弦相似度和欧几里得距离度量[26]。有趣的是,使用欧几里得距离函数时,损失从未减少。
最后,在为每个窗口计算所有测试对的余弦相似度得分后,我们发现当 11 11 11个窗口中的 9 9 9票和 10 10 10票时, DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 性能是可比较的,而当 8 8 8票和 11 11 11票时,性能有所下降(图5b)。因此,我们决定如果流对在 11 11 11个窗口中至少有 9 9 9票为 1 1 1票,则认为它们是相关的,因为 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 在低于 1 0 − 4 10^{-4} 10−4的 FPR \text{ FPR } FPR 下略微增加了 TP \text{ TP } TP 。
D. 指标
在本节中,我们介绍第VI节中使用的 TPR \text{TPR} TPR、 FPR \text{FPR} FPR和 BDR \text{BDR} BDR指标的定义。
- TPR \text{TPR} TPR: 真阳率是真正相关流对被分类为“相关”的比例。
- FPR \text{FPR} FPR: 假阳率是不相关流对被分类为“相关”的比例。
-
BDR
\text{BDR}
BDR: 流量关联中的贝叶斯检测率是在关联函数检测为“相关”的情况下,流对实际上是“相关”的概率,其计算公式为:
P ( P ∣ C ) = P ( C ∣ P ) P ( P ) P ( C ∣ P ) P ( P ) + P ( C ∣ N ) P ( N ) , P(P|C) = \frac{P(C|P)P(P)}{P(C|P)P(P) + P(C|N)P(N)}, P(P∣C)=P(C∣P)P(P)+P(C∣N)P(N)P(C∣P)P(P),
其中 P ( P ) P(P) P(P)是流对相关的概率, P ( C ) P(C) P(C)是流量关联函数将流对判断为相关的概率,而 P ( C ∣ P ) P(C|P) P(C∣P)和 P ( C ∣ N ) P(C|N) P(C∣N)分别用 TPR \text{TPR} TPR和 FPR \text{FPR} FPR替换。
我们注意到精度通常用于替代 BDR \text{BDR} BDR。我们在本文中选择 BDR \text{BDR} BDR,因为基率的影响在计算中显示得更为清晰。
图6. DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA (损失≈ 0.0018 0.0018 0.0018)和 DeepCorr \text{ DeepCorr } DeepCorr 在局部和全局阈值下的性能。
此外,我们通过改变关联阈值参数,使用 ROC \text{ROC} ROC曲线来测量最新攻击和 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 的性能。
E. 相似度阈值
在 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 中,嵌入特征关联阈值 τ \tau τ 用于控制在给定时间窗口内被分类为“可能相关”的每个 Tor \text{ Tor } Tor 轨迹的出口轨迹数量。我们可以通过设置一个适用于所有余弦相似度的全局阈值 τ \tau τ 间接控制这个数量(通常,随着 τ \tau τ 增加,被分类为可能相关的对会减少);或者我们可以直接控制这个数量,通过将离给定 Tor \text{ Tor } Tor 轨迹窗口 t i t_i ti 最近的 κ \kappa κ 个出口轨迹(由 c o s ( G ( t i ) , H ( x j ) ) cos(G(t_i), H(x_j)) cos(G(ti),H(xj))测量)分类为可能相关。这后一种选择对应于为每个 t i t_i ti计算一个局部阈值,通过对列表 d i , 1 , . . . , d i , n d_{i,1},...,d_{i,n} di,1,...,di,n进行排序,其中 d i , j = c o s ( G ( t i ) , H ( x j ) ) d_{i,j} = cos(G(t_i), H(x_j)) di,j=cos(G(ti),H(xj)),并选择第 κ \kappa κ 个元素作为 t i t_i ti 的阈值。
我们探索了这两种方法,发现如图6所示,随着 τ \tau τ的增加(那些产生的 FPR \text{FPR} FPR低于 1 0 − 3 10^{-3} 10−3), TP \text{TP} TP的数量下降得更快,而 κ \kappa κ增加,可能是由于某些窗口中许多流具有相似的嵌入。通过局部选择阈值(即基于每个 Tor \text{ Tor } Tor 流的成对得分分布), DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 能够检测更多的相关流,同时控制 FP \text{FP} FP的数量。
我们还评估了使用局部阈值的 DeepCorr \text{ DeepCorr } DeepCorr ,尽管他们在论文中采用了全局阈值。如图6所示,使用 κ \kappa κ并没有改善 DeepCorr \text{ DeepCorr } DeepCorr 的性能, FPR \text{FPR} FPR也没有下降到 1 0 − 3 10^{-3} 10−3以下,这表明大多数不相关对的关联得分与相关对的得分相似,减少 κ \kappa κ并没有帮助减少假阳性。因此,我们对 DeepCorr \text{ DeepCorr } DeepCorr 使用 τ \tau τ ,对 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 采用 κ \kappa κ 作为曲线参数,在第VI节中生成 DeepCoFFEA \text{ DeepCoFFEA } DeepCoFFEA 的 ROC \text{ROC} ROC曲线。
注释
-
【1】贝叶斯检测率
- 贝叶斯检测率(Bayesian Detection Rate,简称 BDRs)是一种用于评估分类器性能的指标,尤其在二分类问题中。这种指标基于贝叶斯决策理论,结合了检测率(也称为灵敏度或召回率)和错误率(误报率)来评估分类器在实际应用中的表现。定义与计算
贝叶斯检测率通过最大化贝叶斯决策理论中的期望收益或最小化期望损失来评估分类器的性能。它可以通过以下几个步骤来理解和计算:
-
混淆矩阵(Confusion Matrix):
- TP(True Positive):正确识别为正类的数量。
- TN(True Negative):正确识别为负类的数量。
- FP(False Positive):错误识别为正类的数量。
- FN(False Negative):错误识别为负类的数量。
-
检测率(Detection Rate,DR):
- 也称为灵敏度或召回率,计算公式为:
DR = TP TP + FN \text{DR} = \frac{\text{TP}}{\text{TP} + \text{FN}} DR=TP+FNTP - 反映了正类被正确识别的比例。
- 也称为灵敏度或召回率,计算公式为:
-
误报率(False Alarm Rate,FAR):
- 计算公式为:
FAR = FP FP + TN \text{FAR} = \frac{\text{FP}}{\text{FP} + \text{TN}} FAR=FP+TNFP - 反映了负类被错误识别为正类的比例。
- 计算公式为:
贝叶斯检测率的计算
贝叶斯检测率结合了检测率和误报率,通过加权平均或其他形式的组合来评估分类器的整体性能。具体计算方法可以根据具体应用场景和贝叶斯决策理论中的损失函数或收益函数进行调整。
贝叶斯决策理论的应用
贝叶斯决策理论用于最小化期望损失或最大化期望收益,具体方法包括:
- 期望损失:对于每个可能的分类结果(TP, TN, FP, FN),计算其损失(或收益)并根据其概率进行加权平均。
- 贝叶斯决策准则:选择使期望损失最小或期望收益最大的决策阈值。
在实际应用中,贝叶斯检测率通常用于: - 入侵检测系统:评估系统在检测真正的入侵行为和误报之间的权衡。
- 医学诊断:评估诊断工具在检测疾病和避免误诊之间的效果。
- 信用卡欺诈检测:评估检测系统在识别欺诈交易和避免误报正常交易之间的表现。
贝叶斯检测率(BDRs)是一种结合了贝叶斯决策理论的分类器性能评估指标,通过考虑检测率和误报率,以及期望损失或收益来衡量分类器的实际应用效果。它在许多实际场景中具有重要的应用价值,帮助优化分类器的性能和决策阈值。
-