【逆向】Yara规则编写安装与使用教程

前言

Yara是一个能够帮助恶意软件研究人员识别和分类恶意软件样本的工具（类似正则表达式）。
规则可以通过文本或二进制的模式被创建，并且每个规则均由一组字符串和一个布尔表达式组成。

//示例规则
rule Test : Trojan
{
    //规则描述
    meta:
        author = "Sunset"
        date = "2020-04-08"
        description = "Trojan Detection"

    //规则字符串
    strings:
        $a = {6A 40 68 00 30 00 00 6A 14 8D 91}
        $b = {8D 4D B0 2B C1 83 C0 27 99 6A 4E 59 F7 F9}
        $c = "UVODFRYSIHLNWPEJXQZAKCBGMT"

    //条件表达式
    condition:
        $a or $b or $c
}

编译下载

项目：https://github.com/virustotal/yara

releases：https://github.com/VirusTotal/yara/releases

--atom - quality - table = FILE             //
- C, --compiled - rules                     //加载编译规则
- c, --count                                //  只打印命中的规则数量
- d, --define = VAR = VALUE                 //定义外部变量
     --fail - on - warnings                 //失败警告
- f, --fast - scan                          //快速匹配模式
- h, --help                                 //显示帮助并退出
- i, --identifier = IDENTIFIER              //  匹配指定名称的规则（使用指定名称的规则进行匹配）
- l, --max - rules = NUMBER                 //匹配多个规则后中止扫描
     --max - strings - per - rule = NUMBER  //设置每个规则的最大字符串数量(默认 = 10000)
- x, --module - data = MODULE = FILE        //将文件内容作为额外数据传递给模块
- n, --negate                               //  只打印不匹配的规则
- w, --no - warnings                        //禁用警告
- m, --print - meta                         //  打印元数据（在命中结果中显示：规则元数据）
- D, --print - module - data                //  打印模块数据（在命中结果中显示：规则名称与样本名称）
- e, --print - namespace                    //打印规则的名称空间
- S, --print - stats                        //打印规则的统计信息
- s, --print - strings                      //  打印匹配的字符串
- L, --print - string - length              //打印匹配的字符串长度（字符串在文件中的偏移与长度）
- g, --print - tags                         //  打印标签（显示命中规则的标签）
- r, --recursive                            //  递归搜索目录（匹配该目录下的所有样本文件）
- k, --stack - size = SLOTS                 //设置最大堆栈大小(默认值为16384)
- t, --tag = TAG                            //  匹配指定标签的规则（使用指定规则标签进行匹配，标签区分大小写）
- p, --threads = NUMBER                     //指定多少线程数来扫描目录
- a, --timeout = SECONDS                    //指定多少秒后中止扫描
- v, --version                              //显示版本信息

规则编写

Yara规则语法类似于C语言，易于编写和理解，每个规则都以关键字“rule”开头，后面跟着一个规则标识符。
标识符必须遵循与C语言相同的词法约定，它们可以包含任何字母数字和下划线，但第一个字符不能是数字。
规则标识符区分大小写，并且不能超过128个字符。以下关键字是保留的，不能用作标识：

注释

你可以像编写C语言一样，在Yara规则中添加注释：

//　单行注释

/*
　　多行注释
*/

字符串

Yara中有三种类型的字符串:
十六进制串：定义原始字节序列

//通配符：可以代替某些未知字节，与任何内容匹配
rule WildcardExample
{
    strings:
       //使用‘?’作为通配符
       $hex_string = { 00 11 ?? 33 4? 55 }

    condition:
       $hex_string
}

//跳转：可以匹配长度可变的字符串
rule JumpExample
{
        strings:
           //使用‘[]’作为跳转，与任何长度为0-2字节的内容匹配
           $hex_string1 = { 00 11 [2] 44 55 }
           $hex_string2 = { 00 11 [0-2] 44 55 }           
           //该写法与string1作用完全相同
           $hex_string3 = { 00 11 ?? ?? 44 55 }

        condition:
           $hex_string1 and $hex_string2
}

//也可以使用类似于正则表达式的语法
rule AlternativesExample1
{
    strings:
       $hex_string = { 00 11 ( 22 | 33 44 ) 55 }
       /*
        可以匹配以下内容:
        00 11  22  55
        00 11  33 44  55
       */
       
    condition:
       $hex_string
}

//还可以将上面介绍的方法整合在一起用
rule AlternativesExample2
{
    strings:
       $hex_string = { 00 11 ( 33 44 | 55 | 66 ?? 88 ) 99 }

    condition:
       $hex_string
}

文本字符串：定义可读文本的部分

//转义符：
    \"        双引号
    \\        反斜杠
    \t        制表符
    \n        换行符
    \xdd      十六进制的任何字节
    
//修饰符：
    nocase：  不区分大小写
    wide：    匹配2字节的宽字符
    ascii：   匹配1字节的ascii字符
    xor：     匹配异或后的字符串
    fullword：匹配完整单词
    private： 定义私有字符串
    
rule CaseInsensitiveTextExample
{
    strings:
        //不区分大小写
        $text_string = "foobar" nocase
        //匹配宽字符串
        $wide_string = "Borland" wide
        //同时匹配2种类型的字符串
        $wide_and_ascii_string = "Borland" wide ascii
        //匹配所有可能的异或后字符串
        $xor_string = "This program cannot" xor
        //匹配所有可能的异或后wide ascii字符串
        $xor_string = "This program cannot" xor wide ascii
        //限定异或范围
        $xor_string = "This program cannot" xor(0x01-0xff)
        //全词匹配(匹配:www.domain.com  匹配:www.my-domain.com  不匹配:www.mydomain.com)
        $wide_string = "domain" fullword
        //私有字符串可以正常匹配规则，但是永远不会在输出中显示
        $text_string = "foobar" private
        
    condition:
        $text_string
}

正则表达式：定义可读文本的部分

条件表达式

你可以在条件表达中使用如下运算符：

all any them

all of them       // 匹配规则中的所有字符串
any of them       // 匹配规则中的任意字符串
all of ($a*)      // 匹配标识符以$a开头的所有字符串
any of ($a,$b,$c) // 匹配a, b，c中的任意一个字符串
1 of ($*)         // 匹配规则中的任意一个字符串

#

//===匹配字符串在文件或内存中出现的次数
rule CountExample
{
    strings:
        $a = "dummy1"
        $b = "dummy2"

    condition:
        //a字符串出现6次，b字符串大于10次
        #a == 6 and #b > 10
}

@

//可以使用@a[i]，获取字符串$a在文件或内存中，第i次出现的偏移或虚拟地址
//小标索引从1开始，并非0
//如果i大于字符串出现的次数，结果为NaN(not a number 非数值)

！

//可以使用!a[i]，获取字符串$a在文件或内存中，第i次出现时的字符串长度   
//下标索引同@一样都是从1开始
//!a 是 !a[1]的简写

at

//===匹配字符串在文件或内存中的偏移
rule AtExample
{
    strings:
        $a = "dummy1"
        $b = "dummy2"

    condition:
        //a和b字符串出现在文件或内存的100和200偏移处
        $a at 100 and $b at 200
}

in

//===在文件或内存的某个地址范围内匹配字符串
rule InExample
{
    strings:
        $a = "dummy1"
        $b = "dummy2"

    condition:
        $a in (0..100) and $b in (100..filesize)
}

filesize

//===使用关键字匹配文件大小
rule FileSizeExample
{
    condition:
       //filesize只在文件时才有用，对进程无效
       //KB MB后缀只能与十进制大小一起使用
       filesize > 200KB
}

entrypoint

//===匹配PE或ELF文件入口点(高版本请使用PE模块的pe.entry_point代替)
rule EntryPointExample1
{
    strings:
        $a = { E8 00 00 00 00 }

    condition:
       $a at entrypoint
}

rule EntryPointExample2
{
    strings:
        $a = { 9C 50 66 A1 ?? ?? ?? 00 66 A9 ?? ?? 58 0F 85 }

    condition:
       $a in (entrypoint..entrypoint + 10)
}

intxxx uintxxx

//===从指定的文件或内存偏移处读取数据
//小端: 有符号整数
int8(<offset or virtual address>)
int16(<offset or virtual address>)
int32(<offset or virtual address>)

//小端: 无符号整数
uint8(<offset or virtual address>)
uint16(<offset or virtual address>)
uint32(<offset or virtual address>)

intxxxbe uintXXXbe

//大端: 有符号整数
int8be(<offset or virtual address>)
int16be(<offset or virtual address>)
int32be(<offset or virtual address>)

//大端: 无符号整数
uint8be(<offset or virtual address>)
uint16be(<offset or virtual address>)
uint32be(<offset or virtual address>)

//应用示例
rule IsPE
{
  condition:
     //判断是否PE文件
     uint16(0) == 0x5A4D and
     uint32(uint32(0x3C)) == 0x00004550
}

of

//===匹配多个字符串中的某几个
rule OfExample1
{
    strings:
        $a = "dummy1"
        $b = "dummy2"
        $c = "dummy3"

    condition:
        //3个字符串只需匹配任意2个
        2 of ($a,$b,$c)
}

for xxx of xxx ：(xxx)

//功能：
对多个字符串匹配相同的条件
//格式：
for AAA of BBB : ( CCC )
//含义：
在BBB字符串集合中，至少有AAA个字符串，满足了CCC的条件表达式，才算匹配成功。
在CCC条件表达式中，可以使用'$'依次代替BBB字符串集合中的每一个字符串。

//for..of其实就是of的特别版，所以下面2个例子作用相同
any of ($a,$b,$c)
for any of ($a,$b,$c) : ( $ )

//在abc3个字符串集合中，至少有1个字符串，必须满足字符串内容与entrypoint相同的条件
for 1 of ($a,$b,$c) : ( $ at entrypoint  )
for any of ($a,$b,$c) : ( $ at entrypoint  )

//所有字符串，在文件或内存中出现的次数必须大于3，才算匹配成功。
for all of them : ( # > 3 )

//所有以$a开头的字符串，在文件或内存中第2次出现的位置必须小于9
for all of ($a*) : (@[2] < 0x9)

for xxx i in (xxx) ：(xxx)

//格式：
for AAA BBB in (CCC) : (DDD)
//含义：
作用与for of类似，只是增加了下标变量与下标范围，具体看示例

//$b在文件或内存中出现的前3次偏移，必须与$a在文件或内存中出现的前3次偏移+10相同
for all i in (1,2,3) : ( @a[i] + 10 == @b[i] ) 
for all i in (1..3) : ( @a[i] + 10 == @b[i] )

//$a每次在文件或内存中出现位置，都必须都小于100
for all i in (1..#a) : ( @a[i] < 100 )

//其它示例
for any i in (1..#a) : ( @a[i] < 100 )
for 2 i in (1..#a) : ( @a[i] < 100 )

引用其它规则

rule Rule1
{
    strings:
        $a = "dummy1"

    condition:
        $a
}

rule Rule2
{
    strings:
        $a = "dummy2"

    condition:
        $a and Rule1
}

全局规则

//全局规则（global rule）可以在匹配其他规则前优先筛选，
//比如在匹配目标文件之前需要先筛选出小于2MB的文件，在匹配其他规则
global rule SizeLimit
{
    condition:
        filesize < 2MB
}

私有规则

//私有规则（private rule）可以避免规则匹配结果的混乱，
//比如使用私有规则进行匹配时，YARA不会输出任何匹配到的私有规则信息
//私有规则单独使用意义不大，一般可以配合"引用其它规则"的功能一起使用
//私有规则也可以和全局规则一起使用，只要添加“Private”、“global”关键字即可
private rule PrivateRuleExample
{
    ...
}

规则标签

//规则标签，可以让你在YARA输出的时候只显示你感兴趣的规则，而过滤掉其它规则的输出信息
//你可以为规则添加多个标签
rule TagsExample1 : Foo Bar Baz
{
    ...
}

rule TagsExample2 : Bar
{
    ...
}

导入模块

//使用“import”导入模块
//你可以自己编写模块，也可以使用官方或其它第三方模块
//导入模块后，就可以开始使用模块导出的变量或函数
import "pe"
import "cuckoo"

pe.entry_point == 0x1000
cuckoo.http_request(/someregexp/)

外部变量

//外部变量允许你在使用YARA -d命令时指定一个自定义数据，
//该数据可以是整数、字符串、布尔变量，具体看以下示例

//使用布尔变量和一个整数变量作为判断条件
rule ExternalVariableExample2
{
    condition:
       bool_ext_var or filesize < int_ext_var
}

//字符串变量可以与以下运算符一起使用：
contains：如果字符串包含指定的子字符串，返回True
matches： 如果字符串匹配给定的正则表达式时，返回True

rule ExternalVariableExample3
{
    condition:
        string_ext_var contains "text"
}

rule ExternalVariableExample4
{
    condition:
        string_ext_var matches /[a-z]+/
}

文件包含

//作用于C语言一样，可以包含其它规则到当前文件中
include "other.yar"

//相对路径
include "./includes/other.yar"
include "../includes/other.yar"

//全路径
include "/home/plusvic/yara/includes/other.yar"

参考资料

https://github.com/virustotal/yara
https://github.com/Yara-Rules/rules
https://yara.readthedocs.io/en/stable/
https://github.com/InQuest/awesome-yara
https://bbs.pediy.com/thread-226011.htm