使用AVISPA进行NSPK协议安全性分析.docx
《使用AVISPA进行NSPK协议安全性分析.docx》由会员分享，可在线阅读，更多相关《使用AVISPA进行NSPK协议安全性分析.docx（14页珍藏版）》请在冰豆网上搜索。
使用AVISPA进行NSPK协议安全性分析
基于AVISPA工具进行NSPK协议分析
一、AVISPA工具介绍
AVISPA分析工具的结构图如图1所示。
HLPSL是一种丰富的、模块化的、基于角色的形式语言，提供了一套包括控制流模式、数据结构、可选择入侵者模式、复杂的安全目标以及不同的密码初始值和代数性质的说明。
这些特性能够使HLPSL很好的描述现代的、工业化规模的协议。
而且，HLPSL不仅支持基于时间片段的逻辑行为的公开语义，还支持基于重写的中间形式化语言IF。
HLPSL2IF自动将HLPSL语言翻译成IF语言，并将它们依次反馈给测试后端。
AVISPA使用了4种后端分析工具来解决安全协议的确认问题：
（1）OFMC（On-the-flyModel-Checker）：
基于IF语言需求驱使的描述，通过探测系统的变迁，OFMC能够完成协议的篡改和有限制的确认。
OFMC支持密码操作的代数性质的规范，以及各种协议模型。
（2）CL-AtSe（Constraint-Logic-basedAttackSearcher）：
CL-AtSe通过强大的简化探测法和冗余排除技术来执行协议。
它建立在模型化的方式上，并且是对密码操作的代数性质的延伸。
CL-AtSe支持输入缺陷探测和处理消息串联。
（3）SATMC（SAT-basedModel-Checker）：
SATMC建立在通过IF语言描述的，有限域上变迁关系的编码的公式，初始状态和状态集合的说明代表了整个协议的安全特性。
此公式将反馈给SAT状态推导机，并且建立的任何一个模型都将转化为一个攻击事件。
（4）TA4SP（TreeAutomatabasedonAutomaticApproximationsfortheAnalysisofSecurityProtocols）：
TA4SP通过树形语言和重写机制估计入侵者的知识。
根据不同的保密特性，TA4SP能够判断一个协议是否有缺陷，或者是几个会合的对话后是否安全。
图1AVISPA工具结构
二、AVISPA工具安装
AVISPA工具在AVISPA官方网站上可以下载，运行在Linux操作系统环境下。
首先，下载并安装AVISPAv1.1版本（本文使用AVISPA1.0版本为例），解压安装包到对应目
录；其次，需要设置工具集的环境变量，将
AVISPA_PACKAGE关联到安装包的绝对路径；最后将
avispa脚本语言设置在命令行解释器的执行目录中。
例如：
用户想安装AVISPA工具集在/opt路径下，命令如下[5]：
cd/opt
tar-xzf/home/xyz/avispa-package-X.Y_Linux-i686.tgz
exportAVISPA_PACKAGE=/opt/avispa-X.Y
exportPATH=$PATH:
$AVISPA_PACKAGE
三、XEmacs模式的使用
（1）XEmacs工具的安装。
AVISPA提供和XEmacs工具的用户友好接口（XEmacs工具是Linux操作系统下的一种编辑器），它们之间支持用户和AVISPA工具集之间的简单交互。
首先，Linux操作系统需要安装XEmacs编辑器；其次，需要对AVISPA进行设置，使其支持XEmacs模式，命令如下：
cd/opt/others
tar-xzvfavispa-mode.tgz
cdtemporary-avispa
makeinstall
（2）XEmacs工具按钮。
AVISPAXEmacs模式提供了一套完整而直观的编译环境对安全协议进行说明和分析。
最常用的分析出发点是通过hlpsl文件开始。
在AVISPA模式下，当XEmacs工具自动侦测出后缀名为“.hlpsl”的文件时，会在XEmacs工具栏上出现对应的AVISPA按钮。
AVISPA按钮的大致功能如下：
AVISPA：
提供选项、模式的定制和改变后端分析工具等功能；
<<和>>：
提供在同一个协议不同的分析文件（例如“.if”，“.atk”等）之间进行导航；
Processfile：
导入编译器对中间文件进行编译和分析，得出结论；
Update：
当一个工具被XEmacs异步导入时，一旦此工具被中断，此按钮将刷新当前的缓存区。
NSPK协议分析
（1）NSPK协议简介
非对称密码体制NSPK协议，协议双方身份认证部分为：
1）A—B：
{N：
，A}K
A首先生成临时值M，加上自己的身份，用B的公开密钥KB加密后发送给B。
2）B—A：
{N：
，N6}K．
B生成临时值N6，加上A的临时值Nn，用A的公开密钥KA加密后发送给A。
3）A—B：
{M}K。
A向B发送经过KB加密的Nj．整个协议采用公开密钥系统，K4，K8分别是A和B的公开密钥．N口，N6是A和B发布的具有新鲜性的临时值（nonce）。
（2）NSPK分析实验
使用AVISPA协议分析工具对安全协议进行分析的一般性过程如下：
首先，将安全协议编码为某种形式化描述语言；然后，根据协议目标和安全属性，给出不同的消息成分的类型；最后，根据分析工作的结果判断协议是否安全，是否达到了预期目标。
（1）分析安全协议，并根据HLPSL语法，将协议进行建模，编辑成后缀名为“.hlpsl”的文件，具体语法见《安全协议形式化分析的研究和实现》；
如下为NSPK协议的hlpsl实现：
rolealice（A,B:
agent,
Ka,Kb:
public_key,
SND,RCV:
channel（dy））
played_byAdef=
localState:
nat,
Na,Nb:
text
initState:
=0
transition
0.State=0/\RCV（start）=|>
State':
=2/\Na':
=new（）/\SND（{Na'.A}_Kb）
/\secret（Na',na,{A,B}）
/\witness（A,B,bob_alice_na,Na'）
2.State=2/\RCV（{Na.Nb'}_Ka）=|>
State':
=4/\SND（{Nb'}_Kb）
/\request（A,B,alice_bob_nb,Nb'）
endrole
rolebob（A,B:
agent,
Ka,Kb:
public_key,
SND,RCV:
channel（dy））
played_byBdef=
localState:
nat,
Na,Nb:
text
initState:
=1
transition
1.State=1/\RCV（{Na'.A}_Kb）=|>
State':
=3/\Nb':
=new（）/\SND（{Na'.Nb'}_Ka）
/\secret（Nb',nb,{A,B}）
/\witness（B,A,alice_bob_nb,Nb'）
3.State=3/\RCV（{Nb}_Kb）=|>
State':
=5/\request（B,A,bob_alice_na,Na）
endrole
rolesession（A,B:
agent,Ka,Kb:
public_key）def=
localSA,RA,SB,RB:
channel（dy）
composition
alice（A,B,Ka,Kb,SA,RA）
/\bob（A,B,Ka,Kb,SB,RB）
endrole
roleenvironment（）def=
consta,b:
agent,
ka,kb,ki:
public_key,
na,nb,
alice_bob_nb,
bob_alice_na:
protocol_id
intruder_knowledge={a,b,ka,kb,ki,inv（ki）}
composition
session（a,b,ka,kb）
/\session（a,i,ka,ki）
/\session（i,b,ki,kb）
endrole
goal
secrecy_ofna,nb
authentication_onalice_bob_nb
authentication_onbob_alice_na
endgoal
（2）在终端中执行分析命令：
./avispa/tmp/NSPK.hlpsl--output=/opt–ofmc，软件将输入的NSPK.hlpsl文件转化为NSPK.if文件，并将其作为分析器的输入语言，其语法格式如下：
%%IFspecificationofcontrib/avispa-library/NSPK.hlpsl
sectionsignature:
state_bob:
agent*agent*public_key*public_key*nat*text*text*set（agent）*nat->fact
state_alice:
agent*agent*public_key*public_key*nat*text*text*set（agent）*nat->fact
sectiontypes:
nb,alice_bob_nb,bob_alice_na,na:
protocol_id
Na,Nb,Dummy_Nb,Dummy_Na,dummy_nonce:
text
set_78,set_77,set_76,set_74,set_70,set_62:
set
5,3,1,State,10,6,4,SID,2,Dummy_State,0,SID2,SID1:
nat
Set_38,Dummy_Set_38,Set_18,Dummy_Set_18,ASGoal:
set（agent）
start,MGoal:
message
Ka,Kb,ka,kb,ki:
public_key
A,B,A2Goal,A1Goal,i,a,b:
agent
sectioninits:
initial_stateinit1:
=
iknows（start）.
iknows（a）.
iknows（b）.
iknows（ka）.
iknows（kb）.
iknows（ki）.
iknows（inv（ki））.
iknows（i）.
state_alice（a,b,ka,kb,0,dummy_nonce,dummy_nonce,set_62,3）.
state_bob（b,a,ka,kb,1,dummy_nonce,dummy_nonce,set_70,4）.
state_alice（a,i,ka,ki,0,dummy_nonce,dummy_nonce,set_74,6）.
state_bob（b,i,ki,kb,1,dummy_nonce,dummy_nonce,set_78,10）
sectionrules:
stepstep_0（A,B,Ka,Kb,Dummy_Na,Nb,Dummy_Set_18,SID,Na）:
=
state_alice（A,B,Ka,Kb,0,Dummy_Na,Nb,Dummy_Set_18,SID）.
iknows（start）
=[existsNa]=>
state_alice（A,B,Ka,Kb,2,Na,Nb,Dummy_Set_18,SID）.
iknows（crypt（Kb,pair（Na,A）））.
secret（Na,na,Dummy_Set_18）.
witness（A,B,bob_alice_na,Na）.
contains（A,Dummy_Set_18）.
contains（B,Dummy_Set_18）
stepstep_1（A,B,Ka,Kb,Na,Dummy_Nb,Set_18,SID,Nb）:
=
state_alice（A,B,Ka,Kb,2,Na,Dummy_Nb,Set_18,SID）.
iknows（crypt（Ka,pair（Na,Nb）））
=>
state_alice（A,B,Ka,Kb,4,Na,Nb,Set_18,SID）.
iknows（crypt（Kb,Nb））.
request（A,B,alice_bob_nb,Nb,SID）
stepstep_2（B,A,Ka,Kb,Dummy_Na,Dummy_Nb,Dummy_Set_38,SID,Na,Nb）:
=
state_bob（B,A,Ka,Kb,1,Dummy_Na,Dummy_Nb,Dummy_Set_38,SID）.
iknows（crypt（Kb,pair（Na,A）））
=[existsNb]=>
state_bob（B,A,Ka,Kb,3,Na,Nb,Dummy_Set_38,SID）.
iknows（crypt（Ka,pair（Na,Nb）））.
secret（Nb,nb,Dummy_Set_38）.
witness（B,A,alice_bob_nb,Nb）.
contains（A,Dummy_Set_38）.
contains（B,Dummy_Set_38）
stepstep_3（B,A,Ka,Kb,Na,Nb,Set_38,SID）:
=
state_bob（B,A,Ka,Kb,3,Na,Nb,Set_38,SID）.
iknows（crypt（Kb,Nb））
=>
state_bob（B,A,Ka,Kb,5,Na,Nb,Set_38,SID）.
request（B,A,bob_alice_na,Na,SID）
sectionproperties:
propertysecrecy_of_na（MGoal,ASGoal）:
=
[]（（secret（MGoal,na,ASGoal）/\iknows（MGoal））
=>contains（i,ASGoal））
propertysecrecy_of_nb（MGoal,ASGoal）:
=
[]（（secret（MGoal,nb,ASGoal）/\iknows（MGoal））
=>contains（i,ASGoal））
propertyauthentication_on_alice_bob_nb（A1Goal,A2Goal,MGoal,SID,SID1,SID2）:
=
[]（（（request（A1Goal,A2Goal,alice_bob_nb,MGoal,SID）
/\~equal（A2Goal,i））
=>witness（A2Goal,A1Goal,alice_bob_nb,MGoal））
/\（（request（A1Goal,A2Goal,alice_bob_nb,MGoal,SID1）
/\request（A1Goal,A2Goal,alice_bob_nb,MGoal,SID2）
/\~equal（A2Goal,i））
=>equal（SID1,SID2）））
propertyauthentication_on_bob_alice_na（A1Goal,A2Goal,MGoal,SID,SID1,SID2）:
=
[]（（（request（A1Goal,A2Goal,bob_alice_na,MGoal,SID）
/\~equal（A2Goal,i））
=>witness（A2Goal,A1Goal,bob_alice_na,MGoal））
/\（（request（A1Goal,A2Goal,bob_alice_na,MGoal,SID1）
/\request（A1Goal,A2Goal,bob_alice_na,MGoal,SID2）
/\~equal（A2Goal,i））
=>equal（SID1,SID2）））
sectionattack_states:
attack_statesecrecy_of_na（MGoal,ASGoal）:
=
iknows（MGoal）.
secret（MGoal,na,ASGoal）&
not（contains（i,ASGoal））
attack_statesecrecy_of_nb（MGoal,ASGoal）:
=
iknows（MGoal）.
secret（MGoal,nb,ASGoal）&
not（contains（i,ASGoal））
attack_stateauthentication_on_alice_bob_nb（A1Goal,A2Goal,MGoal,SID）:
=
request（A1Goal,A2Goal,alice_bob_nb,MGoal,SID）&
not（witness（A2Goal,A1Goal,alice_bob_nb,MGoal））&
not（equal（A2Goal,i））
attack_statereplay_protection_on_alice_bob_nb（A2Goal,A1Goal,MGoal,SID1,SID2）:
=
request（A1Goal,A2Goal,alice_bob_nb,MGoal,SID1）.
request（A1Goal,A2Goal,alice_bob_nb,MGoal,SID2）&
not（equal（SID1,SID2））&
not（equal（A2Goal,i））
attack_stateauthentication_on_bob_alice_na（A1Goal,A2Goal,MGoal,SID）:
=
request（A1Goal,A2Goal,bob_alice_na,MGoal,SID）&
not（witness（A2Goal,A1Goal,bob_alice_na,MGoal））&
not（equal（A2Goal,i））
attack_statereplay_protection_on_bob_alice_na（A2Goal,A1Goal,MGoal,SID1,SID2）:
=
request（A1Goal,A2Goal,bob_alice_na,MGoal,SID1）.
request（A1Goal,A2Goal,bob_alice_na,MGoal,SID2）&
not（equal（SID1,SID2））&
not（equal（A2Goal,i））
（3）分四种方式对NSPK协议进行分析，操作命令如下：
./avispacontrib/avispa-library/NSPK.hlpsl--output=/opt--ofmc
./avispacontrib/avispa-library/NSPK.hlpsl--output=/opt--cl-atse
./avispacontrib/avispa-library/NSPK.hlpsl--output=/opt--satmc--solver=sim
./avispacontrib/avispa-library/NSPK.hlpsl--output=/opt--ta4sp
软件经过分析，会给出分析结果：
1）OFMC模式
分析结果如下：
%OFMC
%Versionof2006/02/13
SUMMARY
UNSAFE
DETAILS
ATTACK_FOUND
PROTOCOL
/opt/NSPK.if
GOAL
secrecy_of_nb
BACKEND
OFMC
COMMENTS
STATISTICS
parseTime:
0.00s
searchTime:
0.02s
visitedNodes:
10nodes
depth:
2plies
ATTACKTRACE
i->（a,6）:
start
（a,6）->i:
{Na
（1）.a}_ki
i->（b,3）:
{Na
（1）.a}_kb
（b,3）->i:
{Na
（1）.Nb
（2）}_ka
i->（a,6）:
{Na
（1）.Nb
（2）}_ka
（a,6）->i:
{Nb
（2）}_ki
i->（i,17）:
Nb
（2）
i->（i,17）:
Nb
（2）
%ReachedState:
%
%secret（Nb
（2）,nb,set_70）
%witness（b,a,alice_bob_nb,Nb
（2））
%contains（a,set_70）
%contains（b,set_70）
%secret（Na
（1）,na,set_74）
%witness（a,i,bob_alice_na,Na
（1））
%contains（a,set_74）
%contains（i,set_74）
%state_bob（b,i,ki,kb,1,dummy_nonce,dummy_nonce,set_78,10）
%state_alice（a,i,ka,ki,4,Na
（1）,Nb
（2）,set_74,6）
%state_bob（b,a,ka,kb,3,Na
（1）,Nb
（2）,set_70,3）
%state_alice（a,b,ka,kb,0,dummy_nonce,dummy_nonce,set_62,3）
%request（a,i,alice_bob_nb,Nb
（2）,6）
看到如上的针对NSPK协议进行的攻击，发现攻击过程的参与者有三个：
主体A、主体B和攻击者C，其中A作为NS公钥协议的初始者，C作为响应者并假冒A和B进行通信和欺骗，从而实现对NS公钥协议的攻击。
整个协议采用公开密钥系统，ABCEEE、、分别是A、B和C的公开密钥，ABNN、是A和B发布的具有新鲜性的随机数（也称临时值，nonce）。
攻击过程为：
首先主体A向C发送包含AN和自己身份的消息1，并用C的公钥CE加密消息1；C收到消息并马上对消息进行解密，而后假冒A向B发送AN和A身份（让B误认为是和A进行通信）的消息1'，并用B的公钥BE进行加密；B接到消息，并向假冒A的C发送用A的公钥加密的消息ABNN、；而后C接到消息2'并立即向A发送；对协议攻击最后一步，A向C发送A、B之间用于通信的共享秘密BN。
这样C就能得到A和B之间的共享秘密BN，从而实现以后对A和B通信内容的监听。
了解完上述攻击的详细过程，我们不难发现根据上述攻击可以使B不能确认最后一条消息是否来自A。
这是由于A从未详细地声明她欲与B对话，因此B不能得到任何保证A知道B是她的对等实体。
2）cl-atse模式
分析结果如下：
SUMMARY
UNSAFE
DETAILS
ATTACK
升级会员 