利用AVISPA证明D2D协议

利用AVISPA证明UAKA-D2D协议

一、UAKA-D2D协议

UAKA-D2D协议核心思想：UAKA-D2D协议（Universal Authentication and Key Agreement protocol for D2D communications）通过消息完整性校验和会话密钥协商帮助通信双方实现安全通信，类似于DH密钥交换协议。

符号说明

符号	含义
$U{E}_i$/$UI{D}_i$	使用者的设备$i$/$i$的身份码
$H{N}_i$/$HNI{D}_i$	$U{E}_i$的本域网/$U{E}_i$本域网的身份码
$V{N}_i$/$VNI{D}_i$	$U{E}_i$的访问网/$U{E}_i$访问网的身份码
$K_i$	$U{E}_i$与$H{N}_i$的共享密钥
$K_{v2v}$	$V{N}_1$与$V{N}_2$的共享密钥
$KDF$	密钥导出函数
$K_{asme}^i$	由$H{N}_i$为$V{N}_i$生成的漫游密钥
$K_{D2D}^i$	由密钥$K_{asme}^i$导出的$D2D$函数密钥，用于生成$D2D$会话密钥
$FI{D}_i$	函数类的身份码
$SI{D}_I$	$D2D$会话的身份码
$HIN{T}_i$	$U{E}_i$的会话密钥线索
$ma{c}_i$	$HIN{T}_i$的消息认证码
$K_s$	$D2D$会话密钥

第1阶段：系统设置

​ 初始化所有参数。

第2阶段：漫游UE注册

1. $U{E}_i(i=1,2)$向$V{N}_i$发送注册请求。

   $U{E}_i\to V{N}_i:(UI{D}_i,HNI{D}_i)$

2. $V{N}_i$收到请求后，先校验它是否与$H{N}_i$存在漫游协议。若存在，则向$H{N}_i$发送认证请求。

​ $V{N}_i\to U{N}_i:(UI{D}_i,VNI{D}_i)$

3. $H{N}_i$收到请求后，先校验$V{N}_i$的合法性，并判断是否与它存在漫游协议。若不存在，$H{N}_i$拒绝该请求；反之，校验$U{E}_i$是否为授权用户。若是，$H{N}_i$生成包含漫游密钥$K_{asme}^i$的认证信息并发送给$V{N}_i$。

   $H{N}_i\to V{N}_i:K_{asme}^i$

   $K_{asme}^i=KDF(K_i,VNI{D}_i,RAN{D}_i)$，$RAN{D}_i$是由$H{N}_i$挑选的随机数。

4. $V{N}_i$使用所接受到的认证信息，使用标准$EPS$ $AKA$认证过程与$U{E}_i$进行相互认证。通过该认证过程，$V{N}_i$和$U{E}_i$从漫游密钥$K_{asme}^i$中导出了$D2D$函数密钥$K_{D2D}^i$。

   $V{N}_i\leftrightarrow U{E}_i:K_{D2D}^i$

   $K_{D2D}^i=KDF(K_{asme}^i,FI{D}_i,RAN{D}_i^{\prime })$，$RAN{D}_i^{\prime }$是由$V{N}_i$选择的随机数，$FI{D}_i$是$D2D$函数类的身份码（保证$U{E}_i$在同一网络中被不同的$D2D$函数类服务时，所得到的$K_{D2D}^i$不同）。

   $D2D$函数密钥$K_{D2D}^i$将被用于生成$D2D$会话密钥。

第3阶段：D2D查找与随机数协商

​ $U{E}_1$和$U{E}_2$通过开放且独立且安全的带外信道共享秘密随机数$R_P$。

第4阶段：生成D2D会话密钥

1. 一个使用者设备（如$U{E}_1$）启动会话密钥生成程序，向它的访问网$V{N}_1$发送$D2D$会话请求。

   $U{E}_1\to V{N}_1:(UI{D}_1,UI{D}_2,VNI{D}_2{)}_{K_{D2D}^1}$

2. $V{N}_1$收到请求后，校验$V{N}_2$的合法性并判断是否与其签署了用于$D2D$服务的协同计算协议。若非，则拒绝该请求；反之，$V{N}_1$生成此次$D2D$会话的身份码$SI{D}_I$，选取随机数$r_1$，向$V{N}_2$发送密钥协商请求。

   $V{N}_1\to V{N}_2:(UI{D}_1,UI{D}_2,r_1,SI{D}_I{)}_{K_{v2v}}$

3. $V{N}_2$收到请求后，先校验$V{N}_1$的合法性并判断是否与其签署了用于$D2D$服务的协同计算协议。若非，则拒绝该请求；反之，$V{N}_2$选取另一个随机数$r_2$，将其与$UI{D}_1$、$UI{D}_2$一起发送给$V{N}_1$。
   $V{N}_2\to V{N}_1:(UI{D}_1,UI{D}_2,r_2{)}_{K_{v2v}}$

4. 完成随机数交换后，$V{N}_1$和$V{N}_2$生成预共享密钥$R_K=r_1\oplus r_2 $并向$UE_1$和$UE_2$发送$D2D$会话确认信息。

   $V{N}_1\to U{E}_1:(UI{D}_2,R_K,SI{D}_I{)}_{K_{D2D}^1}$

   $V{N}_2\to U{E}_2:(UI{D}_1,R_K,SI{D}_I{)}_{K_{D2D}^2}$

5. $U{E}_1$和$U{E}_2$收到信息后，提取其中的用户身份码，校验其是否与$D2D$查找步骤中的身份信息相同。若两身份信息相匹配，$U{E}_1$和$U{E}_2$调用$DH$密钥交换协议来生成$D2D$会话密钥。

   首先，$U{E}_1$和$U{E}_2$各自选择随机数$a$和$b$来生成他们的会话密钥线索,并利用共享密钥$K_M$计算$HIN{T}_1$和$HIN{T}_2$的消息认证码$ma{c}_1$和$ma{c}_2$。

   $U{E}_1:HIN{T}_1=g^a,ma{c}_1=HMA{C}_{K_M}(HIN{T}_1,T_1)$

   $U{E}_2:HIN{T}_2=g^b,ma{c}_2=HMA{C}_{K_M}(HIN{T}_2,T_2)$

   $K_M=R_P\oplus R_K$，$T_1$和$T_2$分别是$U{E}_1$和$U{E}_2$本地时钟的时间戳。

   然后，$U{E}_1$和$U{E}_2$交换它们的线索、消息认证码和时间戳。

   $U{E}_1\to U{E}_2:(HIN{T}_1,ma{c}_1,T_1)$

   $U{E}_2\to U{E}_1:(HIN{T}_2,ma{c}_2,T_2)$

6. 收到线索后，$U{E}_1$和$U{E}_2$分别校验时间戳的新鲜性并通过计算它们所收到线索的消息认证码来校验它们所收到的消息是否正确。若双方均校验通过，则双方各自生成$D2D$会话密钥$K_s$，并使用$K_s$来保护他们之间的通信。

   $K_s={HIN{T}_1}^b={HIN{T}_2}^a$

二、利用AVISPA证明UAKA-D2D协议

1. 创建角色

%%UE1
role role_UE_init(UE1,UE2,VN1,VN2: agent, 
			      K1D2D: symmetric_key, 
                  H: hash_func, 
                  G,RP: text, 
                  Snd,Rcv: channel(dy)) 
played_by UE1 def= 
local State:nat,
      Ra,T1,T2,RK,KM,SIDI:text,
      HINT1,HINT2,Mac1,Mac2,Ks:message

const secks1,secks2,aut:protocol_id
    	  
init State:=0
    
transition
	% Beginning.If UE1 recieves 'start' signal,then UE1 send (UE1,UE2,VN2) to VN1.
	1. State=0 /\ Rcv(start) =|> State':=1 /\ Snd({UE1.UE2.VN2}_K1D2D)
	% 5. If UE1 receives (UE2,RK,SIDI), UE1 computes HINT1,mac1 and generates T1, then sends them to UE2.
	2. State=1 /\ Rcv({UE2.RK'.SIDI'}_K1D2D) =|> Ra':=new() /\ HINT1':= exp(G,Ra') /\ T1':=new() /\ KM':= xor(RK',RP) /\ Mac1':={H(HINT1'.T1')}_KM' /\ Snd(HINT1'.Mac1'.T1') /\ witness(UE1,UE2,aut,KM') /\ State':= 2
	3. State=2 /\ Rcv(HINT2'.Mac2'.T2') =|> Ks':=exp(HINT2',Ra) /\ secret(Ks',secks1,{UE1,UE2}) /\ request(UE1,UE2,aut,KM) /\ State':=3
 	
end role

%%UE2
role role_UE_resp(UE1,UE2,VN1,VN2: agent,
	         K2D2D: symmetric_key, 
             H: hash_func,
             G,RP: text,
             Snd,Rcv: channel(dy))
played_by UE2 def= 
local State:nat,
      Rb,T1,T2,RK,KM,SIDI:text,
      HINT1,HINT2,Mac1,Mac2,Ks:message

const secks1,secks2,aut:protocol_id    	

init State:=0
    
transition
% 5. If UE2 receives (UE1,RK,SIDI), UE2 computes HINT2,mac2 and generates T2, then sends them to UE1.

2. State=0 /\ Rcv({UE1.RK'.SIDI'}_K2D2D) =|> Rb':= new() /\ HINT2':= exp(G,Rb') /\ T2':=new() /\ KM':= xor(RK',RP) /\ Mac2':= {H(HINT2'.T2')}_KM' /\ Snd(HINT2'.Mac2'.T2') /\ State':= 1
3. State=1 /\ Rcv(HINT1'.Mac1'.T1') =|> Ks':=exp(HINT1',Rb) /\ secret(Ks',secks2,{UE1,UE2}) /\ request(UE2,UE1,aut,KM) /\ State':=2

end role

%%VN1
role role_VN_init(UE1,UE2,VN1,VN2: agent,
                  K1D2D,Kv2v: symmetric_key,
				  SIDI: text,
                  Snd,Rcv: channel(dy))
played_by VN1 def=
local State: nat,
      R1,R2,RK: text
		  
init State:=0
    
transition
%2. If VN1 recieves (UE1,UE2,VN2) from UE1,then VN1 send (UE1,UE2,r1,SIDI) to VN2

1. State=0 /\ Rcv({UE1.UE2.VN2}_K1D2D) =|> R1':=new()  /\ Snd({UE1.UE2.R1'.SIDI}_Kv2v) /\ State':=1
   %4. After exchanging randoms with VN2,VN1 send confirmation message (UE2,RK,SIDI) to UE1
2. State=1 /\ Rcv({UE1.UE2.R2'}_Kv2v) =|> RK':=xor(R1,R2')  /\ Snd({UE2.RK'.SIDI}_K1D2D) /\ State':=2

end role

%%VN2
role role_VN_resp(UE1,UE2,VN1,VN2: agent,
             	  K2D2D,Kv2v: symmetric_key,
				  SIDI: text,
                  Snd,Rcv: channel(dy))
played_by VN2 def=
local State: nat,
      R1,R2,RK: text
		  
init State:=0
    
transition
%3. If VN2 recieves (UE1.UE2.r1,SIDI) from VN1,then VN2 send (UE1,UE2,r2) to VN1

1. State=0 /\ Rcv({UE1.UE2.R1'.SIDI'}_Kv2v) =|>  R2':=new() /\ Snd({UE1.UE2.R2'}_Kv2v)
   %4. After exchanging randoms with VN1,VN2 send confirmation message (UE1,RK,SIDI) to UE2
   /\ RK':=xor(R1',R2') /\ Snd({UE1.RK'.SIDI}_K2D2D) /\ State':=1

end role

2. 完成角色创建后，生成会话

role session(UE1,UE2,VN1,VN2 : agent,
	         K1D2D, K2D2D, Kv2v : symmetric_key) 
def=
  local SUE1,RUE1,SUE2,RUE2,SVN1,RVN1,SVN2,RVN2: channel (dy),
        G,RP,SIDI:text,
        H: hash_func

  composition
	role_UE_init(UE1, UE2, VN1, VN2, K1D2D, H, G, RP, SUE1, RUE1)
	/\ role_UE_resp(UE1, UE2, VN1, VN2, K2D2D, H, G, RP, SUE2, RUE2)
	/\ role_VN_init(UE1, UE2, VN1, VN2, K1D2D, Kv2v, SIDI, SVN1, RVN1)
	/\ role_VN_resp(UE1, UE2, VN1, VN2, K2D2D, Kv2v, SIDI, SVN2, RVN2)

end role

3. 完成会话创建后，创建环境

role environment()
def=
  const secks1,secks2,aut: protocol_id,
		ue1,ue2,vn1,vn2 : agent,
        k1D2D, k2D2D,kv2v: symmetric_key
  intruder_knowledge = {ue1, ue2, vn1, vn2}

  composition
	session(ue1, ue2, vn1, vn2, k1D2D, k2D2D, kv2v)
end role

4. 完成环境创建后，设置安全分析目标

%%goal
goal

secrecy_of secks1, secks2
authentication_on aut

end goal

5. 执行代码

environment()

6. 协议执行过程模拟

（1）协议流程模拟

（2）攻击者攻击过程

7. 安全分析结果