Scyther-manual ------BNF

1、Scyther 协议安全模型的验证实例

第一部分：  打开协议模型 ，设置攻击变量的参数执行分析

Scyther  is a tool for the formal analysis o the security protocol under the perfect Cryptography , the result Window shows a summary of ths clamis in the proctol ,and the verfication results .here one can find whether the protocol is  correct ， or false， and explanation of the possible outcomes of the verfication process ,most important ,if a protocol claim is incorrect , then  there  exists at  least one attack on the protocol ,  A button is show next to the claim .press this buttom to view  the attacks on the claim .as show in the figure (it's not EtherNet/IP  )  it's  Needham-Schroeder   encryption protocol  。

第二部分： Scyther 的描述性语言语法

Scyther 使用的描述性语言基于C/Java 语法，可以使用java语法的注释形式，空白的编译的时候会被忽略（提高程序的可读性）标识符说那个字符串+数字+^ 或者 -

1、Scyther 核心元素是在文件中的描述的协议定义，最小的一个协议定义如下，定义了连那个协议的角色，括号中可以定义角色的行为。

protocol ExampleProtocol(I,R) {
                              role I { };
                            role R { }

};

很多安全协议依赖随机生成的值，我么可以在一个角色中使用 fresh 关键字声明一个类型为Nonce的随机变量 Na

role X (...){

fresh Na : Nonce;

send_1(X, Y, Na)；

}

代理可以使用变量来存储接收到的术语 ，列如我们收到一个临时变量 Na ,定义如下（变量一定要初始化，在发送事件中）

role  Y (......){

var Na  : Nonce；

recv_1(X ,Y , Na)；

}

2、任意两个可以构造成一个属于对，可以将属于  x  ,y  写成 （x, y）,亦可以使用元祖的便是方式 （x, y ,z） ，在Scyther 中可以解释成（（x ,  y）, z）。

对称秘钥：

任意一个术语可以作为对称加密的秘钥，使用术语 kir 加密  ni 写成  { ni } kir  这样表示对称加密  ，除非kir 被明确的定义成非对称加密术语

一个对称秘钥的基础是之前定义的 k ( x ， y) , 表示 长期在  X 和 Y 之间 同步秘钥

非对称秘钥：

公钥基础 PKI 是预先定义的，  sk( X ) 指定一个长期的私钥 X ，同时 pk (X) 指定 表示对应的公钥

比方说： 考虑到    {ni }pk (I)  术语， 表示使用随机变量 ni 被公钥加密 ，只有拥有 私钥 sk (I) 的代理才能解密

哈希函数：

哈希函数式最基本的加密函数，通常使用标识符 hashfunction 定义 一个哈希函数 ： hashfunction H1 ;   哈希函数声明是全局的，定义在所有函数的外部。声明之后可以在协议中使用 加密消息   ： H1（ni）

3、预先定义类型

agent : 表示用来代理的类型

function ： 表示特殊函数，类型与哈希函数 h(x) ,h 代表一种类型的函数体

Nonce:   一种标准类型， 在 Scyther 中被定义

Ticket :   类型变量，可以被任何术语替换

4、用户类型

可以定义一个新的用户类型 ，使用关键字 usertype

usertype  MyatomicMessage;

protocol   X (X, R){

role I {

var y :MyAtomicMessage;

recv_1(I, R , y);

}

}

新声明的类型只能使用该类型的消息变量进行实例化。通过定义一个用户类型，建模这可以通知工具变量只能使用该类型的术语进行实例化，而不能使用Nonce 的类型，

5、事件

接受和发送事件

关键字  recv  和   send  分别标记接受和发送消息  （在一些协议中存在 read 关键字，这是过时的语法，可以用recv安全的替代，通常情况，每一个send 事件都会有一个recv 事件匹配，指定每个事件相同的标签

在某些协议中，我们可能希望直接模拟发送或者接受对手，在这种情况之下没有相对应的事件，如果send或者recv事件 没有响应的事件，Scyther会输出警告，为了抑制警告使用标签进行预处理：如下：

send_! 1( I ,I , LeakToAdversary) ;

6、声明事件和安全属性

声明事件在角色规范中用于建模的预期安全属性。 下面的 Ni 表示被加密 ：claim  ( I , Secret ，Ni)

一下是预定义的几个关键字：

Secret  :   此种声明需要参数术语，可以在文档1 中找到资料

SKR：

Alive :    所有角色的活动 在文件4 中定义

weakagree :    协议的（所有的角色）在文件 4中定义

7、事假

Empty :   此声明不会被验证，会被忽略，只有当Scyther 用作其他验证的后端的后端是才会被弃用。

8、内部计算/模式匹配事件

在文档1 中定义了两个基本事件，可以模拟 内部计算

新事件匹配事件，指定模型 ： match (pt ,m)

在操作的时候，如果存在很好的类型的替换 ，该事假可以执行，后续的执行过程中将会替换

此事件可以模拟各种模型构造，如等量测试，延迟解密、会话检测、除此之外还能用在内部模型计算指定：

Var X: NOnce；

Var Y;

recv(R，I, X);

match(Y, hash(X，I,R));

send（I,R，Y {Y}sk（I））;

在上面的列子中，我们使用   hash (X,I,R)替换了 Y ，

9、不匹配事件

第二种事件是不匹配事件   ，表达方式： not match（pt，m）,不匹配事件和前面的匹配事件正好相反，如果么有可以替代的 如下替换的变量，则事件可以执行。

这种事件可以用来建模，例如，不平等约束、执行模型通过代理执行会话，在一些情况下，我们希望执行这种行为，但是协议不允许。列如：

role  A {

not match(A  B);

send (A,B, m1);

}

模拟一个角色，其实例向其他代理发送消息，最高级的用法就是 匹配和不匹配同时在两个角色中一起使用，常见的实例是模拟 if  ....then......else 构造中。

10、角色定义

角色定义事件序列：声明、发送、接受、或者生声明事件

role Server {

var   x ,y z ：Nonce;

fresh n,m:    Nonce;

send_1(Server, Init,  m  , n);

recv_2(Init, Server, x, y { z}pk(Server)  );

}

11、协议定义

协议定义将一系列的角色作为参数，在协议体中定义

Protocol MyPrrot(Init, Resp， Server){

role Init  {

........

}

role Resp {

............

}

role Server {

..........

}

}

12、帮助协议

在相应的协议前面加上@符号表示  渲染输出图的时候使用，目的是将协议标注为 “helper protocol ”, 此类协议通常用于描述对手能力，在渲染输出的时候，Scyther 收拢实例角色帮助协议折叠成单个节点，这样能够使得图像更加具有可读性。

13、对称---角色 协议

协议注释成对称协议角色，这样指导Scyther工具使用适当的伙伴关系

symmetric-role protocol MyProt( Init ,Resp)

{

role Init  {

........

}

role Resp {

............

}

role Server {

..........

}

}

13、全局声明

在很多应中使用全局常量， 包括 字符串常量、标签、协议标识符，他们的建模和使用方式如下：

usertype  String ;

const  HelloWorld ： String；

Protocol hello (I, R){

role I {

send_1(I,R, Helloworld);

}

role R{

recv_1（I,R,HelloWorld);

}

}

14、宏定义

使用缩略对特定的术语，语法如下：

macro  MyShortcut=LargeTerm;

比方说一个协议中存在复杂的消息或者大量重复的元素，宏定义可以简化协议规范

hashfunction h;

protocol  macro-exmaple-one (I, R){

role I{

fresh nI: Nonce;

macro m1=h(I,ni);

send_1(I,R {m1}pk(R));

claim(I,Select, m1);

}

role R{

var X: Ticket;

recv_1(I,R,{X}pk(R));

}

}

宏具有全局范围， 并在语法级处理，这也允许协议消息的全局缩写：

hashfunction  h;

macro m1={I,R,nI,h(nI,R)} pk(R);

protocol marco-example-two(I,R){

role I {

fresh nI:Nonce；

send_1(I,R,m1);

}

Role R{

var nI: Noce;

recv_1(I,R,m1);

}

}

在上面的代码中 nI 是角色  I 中一个新生成的nonce ，角色R  中的一个变量，因为宏定义在语法上展开，相同的宏可以涉及两个术语。

14、include 导入外部文件

include "filename"

15、one-role-per-agent

操作语义允许代理执行任何角色，甚至可以并行执行多个不同的角色。 此建模选择对应于最糟糕的情况，其中攻击者可以利用最多的选项。 但是，在许多具体设置中，代理只执行一个角色。 例如，该组服务器可以与该组客户端不相交，或者该组RFID标签可以与该组读取器不相交。 在这种情况下，我们不需要考虑利用代理可以执行多个角色的攻击。 这可以通过以下方式建模:

option "--one-role-per-agent"；// disallow agent in mutiple roles

这将会引起Scyther 工具忽略代理执行多个角色的攻击，换句话说，这对一个每个角色由一组专用的代理执行情况。

16、语言 BNF

-------  输入文件：

一个输入文件时一系列spdl 结构， 是一种全局定义护着协议描述

<spdlcomplete>::==<>spdl{';' <spdl>}

<spdl>::=<globaldeclaration>

| <protocol>

-------- 协议定义：使用基于角色的方法描述一个角色， 比方说 一个协议 n3  现在在协议中定义一个角色  I 。我们可以使用 n3.I  调用该角色

<protocol>::='protocol' <id>'(<termlist>') '{'<roles>'}' ['; ']

...............角色

<roles>::=<role>[<roles>]

| <declaration>[<roles>]

<role>::=['singular']'role'<id>'{' <roledef>'}' [';']

<roledef>::=<event>[<roledef>]

| <declaration> [<roledef>]

---------------事件

<event>::'recv'<alble>'('<front>','<termlist>')' ';'

|' send' <lable> '(' <front> ',' <termlist> ')' ';'

| 'claim' [<lable>] '(' <from> ',' <claim> [ ',' <>trmlist] ')' ';'

<lable>::='_' <term>

<form>::=<id>

<to>:==<id>

<claim>:==<id>

------------------------------声明

<globaldeclatration>::=<declaration>

| 'untrusted'  <termlist> ';'

| 'usertype'< termlist> ';'

<declaration>::=['secret'] 'const' <termlist>[':'<type>]';'

| [secret'] 'fresh' <termlist> [';'<'termlist>]';'

| 'secret' 'var' <termlist> [';' <termlist>]';'

|'inversekeys' '(' <termlist>';' <termlist>')' ';'

|' compromised' <termlist>';'

<type>::=<id>

<tupelist>::=<type>{'.' <type>}

...........................条款(Trerms)

<term>::=<id>

|'{' <termlist> '}' <key>

| '(' <termlist> ')'

| <id> '(' <termlist> ')'

<key>::=<term>

<termlist>::=<term>{',' <term>}

17、安全协议建模

介绍：在Scyther工具直接破那个分析正确的安全协议要掌握基本的模型符号：在文档1中有详细的说明， 符号分析主要集中在下面的几个方面：

*  ： 协议中的逻辑消息组件以及预期功能 （公共对抗秘钥，每次运行的新生成的，或者常亮）

*： 消息结构   （配对 加密  签名   哈希）

*：  消息流   （顺序、 参与代理）

18、 Needham-Schroeder public Key    协议形式化安全分析

首先添加描述这个协议   采用注释的方式 描述这个协议：

/*******

*  Needham -Schroeder  protocol

******  *****/

这个协议用两个角色，触发角色I  和响应角色  R  , 使用单独的一行进行简单的备注

// the  Protocol  description

protocol   ns3(I,R）{

//// Scyther 的工作是基于角色的描述，首先建立发出（触发）角色，这个角色有两个值， 临时创建两个

role  I {

fresh  ni:Nonce ;

var    nr: Nonce;

////此处为协议通信建模   该协议存在三个消息，发起者发送第一条和最后一条消息，send 和recv 关键字末尾的标签，这些仅用于消息序列图中；链接箭头的信息。

send_1(I,R,{I, ni}pk(R) );

send_2(R,I{ni,nr}pk(I) );

send_3(I,R,{nr}pk(R) );

///    这里检查生成和接受到的 nonce ，着这里我们检查协议的保密性而非同步性

claim_i1(I,Secret,ni);

claim_i2( I,Secret ,nr);

claim_i3(I,Niagree);

claim_i4(I,Nisynch)

} /////综上完成冷发起角色的规范

/// 下面是消息接受者的角色，不同于发起者角色的是：

////  第一 ： 关键子  var和 fresh 交换位置 ,  ni 是由 I 创建的，并创建值，但是对R来说 接受到的是一个变量，

/////第二：   关键 send 和 recv 交换了位置

//////第三  :  声明必须有唯一的标签，因为想现在已经改变，所以执行声明的角色是R不是 I

//////响应者完整角色描述如下：

role R{

var ni : Nonce ；

fresh nr: Nonce ;

recv_1( I,R {I ,ni}pk(R) ) ;

send_2(R,I,{ni,nr}pk(I) );

recv_3(I ,R.{nr}pk(R) );

claim_ri(R,Secret,ni );

claim_r2(R,Secret,nr );

claim_r3(R,Niagaree);

claim_r4(R,Nisynch);

}

} ///Needham-Schroeder 全部的协议会在  附录1 中给出

第八章、使用Scyther 工具的 GUI界面

Scyther工具有两种主要的方式，图形界面和命令的形式，下面说明使用Scyther 的GUI 如何输出，验证 Needham-Schroeder 公钥协议结果如下图所示，  发起角色 n3 ，I  对 无限次的运行时正确的。这个响应的声明都是错误的， Scyther 报告在思想声明中，至少存在一个错误，在下面的结果图分成几列，

第一例表示声明的协议，

第二列显示的角色，

第三例显示唯一的声称表示，

第四列显示声称的类型和声明的参数，

第五列显示给出了验证过程的实际结果，当声称是错误的他显示Fail ，声称是正确的显示 OK。

第六列完善了前面的陈述，如果显示verified 这个声明是正确的，如果显示Falsified ,则声明是错误的，如果这个列显示是空 的，这时声明 fail/OK 取决于指定的边界设定

第七列 用于进一步解释结果的状态，每个包含一个句子：详细解释如下：

*** at least X attacks  -------状态空间中找到攻击，因为不可判定性原因，或者搜索的分支或者结构，不能够确定时候还存在其他攻击

Finger                Scyther results for the Needham-Schroeder protocol

***在默认的设置下 Scyther找到攻击后会 停止验证进程，

****** Exactly X attacks : 在状态空间内，存在确定的几个攻击变量 ，没有其他攻击

******* At least X pattern

******* Exactly X pattern :状态抵达，发生在不可达声称中，发现的状态不是真正的攻击 ，而是抵达状态

******* NO attacks within bounds ：在绑定的状态空间没有发现攻击，但是约束空间外可能存在攻击

****** NO attacks ：在绑定的状态空间没有发现攻击，并且可以构造证明即使在状态空间外，这样就证明的协议的安全属性。

注意的是：由于算法的性质，即使在有界的状态也能得到这样的结果

第   8.2 限制状态空间

验证时间通常会随着最大运行的数量呈现指数的增长形式。

8.3 攻击图

每个垂直轴表示一个运行（一个协议实例角色）  ,如此图，我们看到涉及到两个运行，每一个运行的开始都是从一个菱形的方框开始，这代表了一个确定的运行，用于提供相关的运行信息，在运行的左手边是攻击信息，

每次运行都分配一个标识符 （此处是1），这个编号随意的，为了区分不同的运行，此处协议中的R角色,，通过Agent1代理执行，认为在和Agent2 进行通信，但是要注意的是，运行 2 由 Agent2 代理，但是  这个代理并不认为他和Agent1进行通信。

在右边的运行中可以看到这个运行的实例角色是 I ,从第二行可以看出哪个代理正在运行，以及正在和哪个通信，在这例子中，运行执行代理是 Agent2  ,认为响应角色被执行被不信任的代理  Agent3

除此之外，运行头包含新生成的值（run 1  生成了值  nr#1）和信息在实例上局部变量（run  1 实例 的变量  ni  和 Nonce  ni#2 或者 run2 ）

8.2.3  事件信息通信

Sned 事件表示发送消息，第一个send  发生在攻击中是第一次发送事件想 run2 ,  send_1(Eve ,{Agent#0 ,ni#2}pk(Eve) )

每次当消息发送的时候，攻击者都可以有效的获得，在这种情况之下，因为攻击者一已经知道了代理 Eve 的私钥 sk(Eve)   ，能解码消息同时学习 nonce   ni#2的值,

接受事件对应着成功接受消息。第一个接受事件能够发生在攻击中是第一个接受到的事件。recv_1(Agent#0,{Agent#9\0,ni#2)pk{Agent#1))

传入箭头不表示发送消息，相反表示一个排序的约束，只有在发生其他事情的时候才会接受到消息，在种情况之下，我们看到当  run 2 发送初始化消息的时候信息才会被接受。原因是 这个nonce ni#2   ,攻击者不能预测这个nonce  ，这样只能等到  run 2 产生 它.

在图中，链接箭头是红色的，并且有一个标签匹配，这是由于发送的消息和接受的消息不匹配的缘故造成。

第九章： 使用Scyther 的命令形式

所用 Scyther GUI 能够提供的功能  Scyther 的命令行形式也可以实现，除此之外，命令行形式提供额一些功能当前不能使用GUI 来实现，    取决于你是用的操作系统，  Scyther的工具的米目录包含下面的执行文件

Scyther/scyther-linux

Scyther/ scyther-win32

Scyther/scyther-mac

在上面的列举中，我们假设linux版本的使用，如果你想使用不同的版本，

第十章   高级主题

*******   非对称秘钥典型的模型有两种在哪个函数，一个函数映射代理到公钥，另一个函数映射代理到私钥，一般来说，每一个代理都有一个密钥对   public / private  pair（排课（x）,sk(x)）,建立非对称秘钥，首先定义两个函数，pk2 加密公钥，sk2加密私钥。

const pk2：Function ;

sercet sk2： function;

也可以声称这个函数代表非对称密钥对   inversekeys(pk2,sk2) ，如果按照这种方式定义，使用pk2（X）加密的术语只能使用sk（x）解密

********近似等式理论

Scyther

建模时间戳和全局计数器

Scyther的底层协议模型目前不支持在代理运行之间共享的变量。

Scyther 界面汉化

Scyther 工具的有事之一是可以有针对性的对目标属性进行形式化藐视，无论是某一个变量的机密性，还是某主题对另一个主体的认证性，用户可以灵活的对目标属性进行描述，Scyther工具还可以针对用户感兴趣的安全属性进行分析和验证， 目标属性的藐视吧通过该claim事件完成，利用claim事件可以对角色的认证性、变量的机密性进行描述