符号 | 含义 |
---|---|
U E i UE_i UEi/ U I D i UID_i UIDi | 使用者的设备 i i i/ i i i的身份码 |
H N i HN_i HNi/ H N I D i HNID_i HNIDi | U E i UE_i UEi的本域网/ U E i UE_i UEi本域网的身份码 |
V N i VN_i VNi/ V N I D i VNID_i VNIDi | U E i UE_i UEi的访问网/ U E i UE_i UEi访问网的身份码 |
K i K_i Ki | U E i UE_i UEi与 H N i HN_i HNi的共享密钥 |
K v 2 v K_{v2v} Kv2v | V N 1 VN_1 VN1与 V N 2 VN_2 VN2的共享密钥 |
K D F KDF KDF | 密钥导出函数 |
K a s m e i K^i_{asme} Kasmei | 由 H N i HN_i HNi为 V N i VN_i VNi生成的漫游密钥 |
K D 2 D i K^i_{D2D} KD2Di | 由密钥 K a s m e i K^i_{asme} Kasmei导出的 D 2 D D2D D2D函数密钥,用于生成 D 2 D D2D D2D会话密钥 |
F I D i FID_i FIDi | 函数类的身份码 |
S I D I SID_I SIDI | D 2 D D2D D2D会话的身份码 |
H I N T i HINT_i HINTi | U E i UE_i UEi的会话密钥线索 |
m a c i mac_i maci | H I N T i HINT_i HINTi的消息认证码 |
K s K_s Ks | D 2 D D2D D2D会话密钥 |
初始化所有参数。
U E i ( i = 1 , 2 ) UE_i(i=1,2) UEi(i=1,2)向 V N i VN_i VNi发送注册请求。
U E i → V N i : ( U I D i , H N I D i ) UE_i \rightarrow VN_i:(UID_i,HNID_i) UEi→VNi:(UIDi,HNIDi)
V N i VN_i VNi收到请求后,先校验它是否与 H N i HN_i HNi存在漫游协议。若存在,则向 H N i HN_i HNi发送认证请求。
V N i → U N i : ( U I D i , V N I D i ) VN_i \rightarrow UN_i:(UID_i,VNID_i) VNi→UNi:(UIDi,VNIDi)
H N i HN_i HNi收到请求后,先校验 V N i VN_i VNi的合法性,并判断是否与它存在漫游协议。若不存在, H N i HN_i HNi拒绝该请求;反之,校验 U E i UE_i UEi是否为授权用户。若是, H N i HN_i HNi生成包含漫游密钥 K a s m e i K^i_{asme} Kasmei的认证信息并发送给 V N i VN_i VNi。
H N i → V N i : K a s m e i HN_i \rightarrow VN_i : K^i_{asme} HNi→VNi:Kasmei
K a s m e i = K D F ( K i , V N I D i , R A N D i ) K^i_{asme} = KDF(K_i, VNID_i, RAND_i) Kasmei=KDF(Ki,VNIDi,RANDi), R A N D i RAND_i RANDi是由 H N i HN_i HNi挑选的随机数。
V N i VN_i VNi使用所接受到的认证信息,使用标准 E P S EPS EPS A K A AKA AKA认证过程与 U E i UE_i UEi进行相互认证。通过该认证过程, V N i VN_i VNi和 U E i UE_i UEi从漫游密钥 K a s m e i K^i_{asme} Kasmei中导出了 D 2 D D2D D2D函数密钥 K D 2 D i K^i_{D2D} KD2Di。
V N i ↔ U E i : K D 2 D i VN_i \leftrightarrow UE_i : K^i_{D2D} VNi↔UEi:KD2Di
K D 2 D i = K D F ( K a s m e i , F I D i , R A N D i ′ ) K^i_{D2D} = KDF(K^i_{asme},FID_i,RAND_i') KD2Di=KDF(Kasmei,FIDi,RANDi′), R A N D i ′ RAND_i' RANDi′是由 V N i VN_i VNi选择的随机数, F I D i FID_i FIDi是 D 2 D D2D D2D函数类的身份码(保证 U E i UE_i UEi在同一网络中被不同的 D 2 D D2D D2D函数类服务时,所得到的 K D 2 D i K^i_{D2D} KD2Di不同)。
D 2 D D2D D2D函数密钥 K D 2 D i K^i_{D2D} KD2Di将被用于生成 D 2 D D2D D2D会话密钥。
U E 1 UE_1 UE1和 U E 2 UE_2 UE2通过开放且独立且安全的带外信道共享秘密随机数 R P R_P RP。
一个使用者设备(如 U E 1 UE_1 UE1)启动会话密钥生成程序,向它的访问网 V N 1 VN_1 VN1发送 D 2 D D2D D2D会话请求。
U E 1 → V N 1 : ( U I D 1 , U I D 2 , V N I D 2 ) K D 2 D 1 UE_1\rightarrow VN_1:(UID_1,UID_2,VNID_2)_{K^1_{D2D}} UE1→VN1:(UID1,UID2,VNID2)KD2D1
V N 1 VN_1 VN1收到请求后,校验 V N 2 VN_2 VN2的合法性并判断是否与其签署了用于 D 2 D D2D D2D服务的协同计算协议。若非,则拒绝该请求;反之, V N 1 VN_1 VN1生成此次 D 2 D D2D D2D会话的身份码 S I D I SID_I SIDI,选取随机数 r 1 r_1 r1,向 V N 2 VN_2 VN2发送密钥协商请求。
V N 1 → V N 2 : ( U I D 1 , U I D 2 , r 1 , S I D I ) K v 2 v VN_1 \rightarrow VN_2: (UID_1,UID_2,r_1,SID_I)_{K_{v2v}} VN1→VN2:(UID1,UID2,r1,SIDI)Kv2v
V N 2 VN_2 VN2收到请求后,先校验 V N 1 VN_1 VN1的合法性并判断是否与其签署了用于 D 2 D D2D D2D服务的协同计算协议。若非,则拒绝该请求;反之, V N 2 VN_2 VN2选取另一个随机数 r 2 r_2 r2,将其与 U I D 1 UID_1 UID1、 U I D 2 UID_2 UID2一起发送给 V N 1 VN_1 VN1。
V N 2 → V N 1 : ( U I D 1 , U I D 2 , r 2 ) K v 2 v VN_2 \rightarrow VN_1: (UID_1,UID_2,r_2)_{K_{v2v}} VN2→VN1:(UID1,UID2,r2)Kv2v
完成随机数交换后, V N 1 VN_1 VN1和 V N 2 VN_2 VN2生成预共享密钥$R_K=r_1\oplus r_2 并 向 并向 并向UE_1 和 和 和UE_2 发 送 发送 发送D2D$会话确认信息。
V N 1 → U E 1 : ( U I D 2 , R K , S I D I ) K D 2 D 1 VN_1\rightarrow UE_1 : (UID_2,R_K,SID_I)_{K^1_{D2D}} VN1→UE1:(UID2,RK,SIDI)KD2D1
V N 2 → U E 2 : ( U I D 1 , R K , S I D I ) K D 2 D 2 VN_2\rightarrow UE_2 : (UID_1,R_K,SID_I)_{K^2_{D2D}} VN2→UE2:(UID1,RK,SIDI)KD2D2
U E 1 UE_1 UE1和 U E 2 UE_2 UE2收到信息后,提取其中的用户身份码,校验其是否与 D 2 D D2D D2D查找步骤中的身份信息相同。若两身份信息相匹配, U E 1 UE_1 UE1和 U E 2 UE_2 UE2调用 D H DH DH密钥交换协议来生成 D 2 D D2D D2D会话密钥。
首先, U E 1 UE_1 UE1和 U E 2 UE_2 UE2各自选择随机数 a a a和 b b b来生成他们的会话密钥线索,并利用共享密钥 K M K_M KM计算 H I N T 1 HINT_1 HINT1和 H I N T 2 HINT_2 HINT2的消息认证码 m a c 1 mac_1 mac1和 m a c 2 mac_2 mac2。
U E 1 : H I N T 1 = g a , m a c 1 = H M A C K M ( H I N T 1 , T 1 ) UE_1:HINT_1 = g^a ,\ mac_1 = HMAC_{K_M}(HINT_1,T_1) UE1:HINT1=ga, mac1=HMACKM(HINT1,T1)
U E 2 : H I N T 2 = g b , m a c 2 = H M A C K M ( H I N T 2 , T 2 ) UE_2:HINT_2 = g^b,\ mac_2 = HMAC_{K_M}(HINT_2,T_2) UE2:HINT2=gb, mac2=HMACKM(HINT2,T2)
K M = R P ⊕ R K K_M=R_P\oplus R_K KM=RP⊕RK, T 1 T_1 T1和 T 2 T_2 T2分别是 U E 1 UE_1 UE1和 U E 2 UE_2 UE2本地时钟的时间戳。
然后, U E 1 UE_1 UE1和 U E 2 UE_2 UE2交换它们的线索、消息认证码和时间戳。
U E 1 → U E 2 : ( H I N T 1 , m a c 1 , T 1 ) UE_1\rightarrow UE_2: (HINT_1,mac_1,T_1) UE1→UE2:(HINT1,mac1,T1)
U E 2 → U E 1 : ( H I N T 2 , m a c 2 , T 2 ) UE_2\rightarrow UE_1: (HINT_2,mac_2,T_2) UE2→UE1:(HINT2,mac2,T2)
收到线索后, U E 1 UE_1 UE1和 U E 2 UE_2 UE2分别校验时间戳的新鲜性并通过计算它们所收到线索的消息认证码来校验它们所收到的消息是否正确。若双方均校验通过,则双方各自生成 D 2 D D2D D2D会话密钥 K s K_s Ks,并使用 K s K_s Ks来保护他们之间的通信。
K s = H I N T 1 b = H I N T 2 a K_s = {HINT_1}^b = {HINT_2}^a Ks=HINT1b=HINT2a
%%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
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
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
%%goal
goal
secrecy_of secks1, secks2
authentication_on aut
end goal
environment()
(1)协议流程模拟
(2)攻击者攻击过程