C/C++源码扫描系列- Fortify 篇

首发于

https://xz.aliyun.com/t/9276

概述

Fortify是一款商业级的源码扫描工具,其工作原理和codeql类似,甚至一些规则编写的语法都很相似,其工作示意图如下:

image.png

首先Fortify对源码进行分析(需要编译),然后提取出相关信息保存到某个位置,然后加载规则进行扫描,扫描的结果保存为 .fpr 文件,然后用户使用 GUI 程序对结果进行分析,排查漏洞。

环境搭建

本文的分析方式是在 Linux 上对源码进行编译、扫描,然后在 Windows 平台对扫描结果进行分析,所以涉及 WindowsLinux 两个平台的环境搭建。

Windows搭建

首先双击 Fortify_SCA_and_Apps_20.1.1_windows_x64.exe 安装

image.png

安装完成后,把 fortify-common-20.1.1.0007.jar 拷贝 Core\lib 进行破解,然后需要把 rules 目录的规则文件拷贝到安装目录下的 Core\config\rules 的路径下,该路径下保存的是Fortify的默认规则库。

image.png

ExternalMetadata 下的文件也拷贝到 Core\config\ExternalMetadata 目录即可

最后执行 auditworkbench.cmd 即可进入分析源码扫描结果的IDE.

image.png

Linux搭建

解压下载的压缩包,然后执行 ./Fortify_SCA_and_Apps_19.2.1_linux_x64.run 按照引导完成安装即可,安装完成后进入目录执行sourceanalyzer来查看是否安装完成

$ ./bin/sourceanalyzer -version
Fortify Static Code Analyzer 19.2.1.0008 (using JRE 1.8.0_181)

然后将 rulesExternalMetadata 拷贝到对应的目录中完成规则的安装。

工具使用

本节涉及代码

https://github.com/hac425xxx/sca-workshop/tree/master/fortify-example

Fortify的工作原理和codeql类似,首先会需要使用Fortify对目标源码进行分析提取源代码中的信息,然后使用规则从源码信息中查询出匹配的代码。

首先下载代码然后使用 sourceanalyzer 来分析源码

/home/hac425/sca/fortify/bin/sourceanalyzer -b fortify-example make

其中

  • -b 指定这次分析的 id
  • 后面是编译代码时使用的命令,这里是 make

分析完代码后再次执行 sourceanalyzer 对源码进行扫描

/home/hac425/sca/fortify/bin/sourceanalyzer -b fortify-example -scan -f fortify-example.fpr

其中

  • -b 指定扫描的 id 和之前分析源码时的 id 对应
  • -scan 表示这次是采用规则对源码进行扫描
  • -f 指定扫描结果输出路径,扫描结果可以使用 auditworkbench.cmd 进行可视化的分析。

image.png

生成 .fpr 结果后可以使用 auditworkbench 加载分析

image.png

system命令执行检测

本节涉及代码

https://github.com/hac425xxx/sca-workshop/tree/master/fortify-example/system_rules

漏洞代码如下

int call_system_example()
{
    char *user = get_user_input_str();
    char *xx = user;
    system(xx);
    return 1;
}

首先通过 get_user_input_str 获取外部输入, 然后传入 system 执行。

下面介绍如何编写 Fortify 规则来识别这个漏洞, 规则文件是一个xml文件,其主要结构如下

<?xml version="1.0" encoding="UTF-8"?>
<RulePack xmlns="xmlns://www.fortifysoftware.com/schema/rules">
    <RulePackID>EA6AEBB1-F11A-44AD-B5DD-F4F66907184E</RulePackID>
    <Version>1.0</Version>
    <Description><![CDATA[]]></Description>
    <Rules version="20.1">
        <RuleDefinitions>
        
            <DataflowSourceRule formatVersion="3.2" language="cpp">
                ....
            </DataflowSourceRule>
            
        </RuleDefinitions>
    </Rules>
</RulePack>
  1. RulePackID 表示这个规则文件的 ID, 设置符合格式的唯一字符串即可
  2. RuleDefinitions 里面是这个xml文件中的所有规则,每个规则作为RuleDefinitions的子节点存在,比如示例中的 DataflowSourceRule 节点,表示这是一个 DataflowSource 规则,用于指定数据流跟踪的 source

我们开发规则实际也只需要在 RuleDefinitions 中新增对应的规则节点即可。

Fortify 也支持污点跟踪功能,下面就介绍如何定义 Fortify 的污点跟踪规则,首先我们需要定义 sourceDataflowSourceRule 规则用于定义污点源,不过这个只支持定义函数的一些属性作为污点源,比如返回值、参数等,代码如下

<DataflowSourceRule formatVersion="3.2" language="cpp">
    <RuleID>AEFA1FBF-3137-4DD8-A65F-774350C97427</RuleID>
    <FunctionIdentifier>
        <FunctionName>
            <Value>get_user_input_str</Value>
        </FunctionName>
    </FunctionIdentifier>
    <OutArguments>return</OutArguments>
</DataflowSourceRule>

这条规则的作用是告知Fortify的数据流分析引擎 get_user_input_str 的返回值是污点数据,规则的解释如下:

  1. 首先 RuleID 用于唯一标识一条规则
  2. FunctionIdentifier 用于匹配一个函数, 其中包含一个 FunctionName 子节点,表示通过函数名进行匹配,这里就是匹配 get_user_input_str 函数
  3. 然后 OutArguments 用于定义污点源, return 表示该函数的返回值是污点数据,如果该节点的值为数字 n , 则表示第 n 个参数为污点数据,n 从0开始计数。

定义好 source 点后,还需要定义 sink 点,DataflowSinkRule 规则用于定义 sink

<DataflowSinkRule formatVersion="3.2" language="cpp">
    <RuleID>AA212456-92CD-48E0-A5D5-E74CC26ADDF</RuleID>
    <Description><![CDATA[]]></Description>
    <VulnCategory>Command Injection</VulnCategory>
    <DefaultSeverity>4.0</DefaultSeverity>
    <Sink>
        <InArguments>0</InArguments>
    </Sink>
    <FunctionIdentifier>
        <FunctionName>
            <Value>system</Value>
        </FunctionName>
    </FunctionIdentifier>
</DataflowSinkRule>

这条规则的作用是设置 system 的第 0 个参数为 sink 点,规则解释如下:

  1. VulnCategory 是一个字符串,会在扫描结果中呈现
  2. FunctionIdentifier 用于匹配一个函数,这里就是匹配 system 函数
  3. SinkInArguments 用于表示函数的第 0 个参数为 sink

规则编写完后,保存成一个 xml 文件,然后在对源码进行扫描时通过 -rules 指定自定义的规则文件即可

/home/hac425/sca/fortify/bin/sourceanalyzer -rules system.xml -b fortify-example -scan -f fortify-example.fpr -no-default-rules

ps: -no-default-rules 表示不使用Fortify的默认规则,这里主要是在自己开发规则时避免干扰。

扫描的结果如下

image.png

由于我们没有考虑 clean_data 函数对外部输入的过滤,所以会导致误报

int call_system_safe_example()
{
    char *user = get_user_input_str();
    char *xx = user;
    if (!clean_data(xx))
        return 1;
    system(xx);
    return 1;
}

可以使用 DataflowCleanseRule 规则来定义这类会对输入进行过滤的函数

<DataflowCleanseRule formatVersion="3.2" language="cpp">
    <RuleID>3EC057A4-AE7A-42C4-BAA0-3ACB36C8AB4B</RuleID>
    <FunctionIdentifier>
        <FunctionName>
            <Value>clean_data</Value>
        </FunctionName>
    </FunctionIdentifier>
    <OutArguments>0</OutArguments>
</DataflowCleanseRule>

规则表示 clean_data 函数执行后其第 0 个参数就是干净的(不再是污点值),此时就可以把外部数据被过滤的场景从查询结果中剔除掉了。

此时的扫描还会漏报 call_our_wrapper_system_custom_memcpy_example ,因为其中使用了custom_memcpy这个外部函数来进行内存拷贝,这样Fortify在进行污点跟踪的时候就会导致污点数据丢失,从而漏报。

int custom_memcpy(char *dst, char *src, int sz);

int call_our_wrapper_system_custom_memcpy_example()
{

    char *user = get_user_input_str();

    char *tmp = malloc(strlen(user) + 1);

    custom_memcpy(tmp, user, strlen(user));

    our_wrapper_system(tmp);
    return 1;
}

我们可以使用 DataflowPassthroughRule 规则来对这个函数进行建模

<DataflowPassthroughRule formatVersion="3.2" language="cpp">
    <RuleID>C929ED5F-9E6A-4CB5-B8AE-AAAAD3C20BDC</RuleID>
    <FunctionIdentifier>
        <FunctionName>
            <Pattern>custom_memcpy</Pattern>
        </FunctionName>
    </FunctionIdentifier>
    <InArguments>1</InArguments>
    <OutArguments>0</OutArguments>
</DataflowPassthroughRule>

规则作用是告知 Fortify 调用 custom_memcpy 函数时,第 1 个参数的污点数据会传播到第 0 个参数,结果如下

image.png

system命令执行检测 # 2

除了使用 DataflowSourceRule 、DataflowSinkRule 等规则来定义污点跟踪相关的属性外,Fortify还支持使用 CharacterizationRule 来定义污点跟踪相关的特性。

其中对应关系如下图所示

image.png

根据文档的使用示例,修修改改很快就可以使用 CharacterizationRule 来搜索出涉及 system 命令执行的代码,代码路径如下

https://github.com/hac425xxx/sca-workshop/blob/master/fortify-example/system_rules/system_CharacterizationRule.xml

介绍具体的 CharacterizationRule 规则实现之前,先介绍一下 StructuralRule 规则,因为 CharacterizationRule 就是通过 StructuralRule 的语法来匹配代码中的语法结构。

StructuralRule 官方文档中的内容如下

The Structural Analyzer operates on a model of the program source code called the structural tree. The structural tree is made up of a set of nodes that represent program constructs such as classes, functions, fields, code blocks, statements, and expressions.

Fortify在编译/分析代码过程中会把代码中的元素(代码块、类、表达式、语句等)通过树状结构体组装起来形成一颗 structural tree,然后扫描的时候使用 Structural Analyzer 来解析 StructuralRule ,最后输出匹配的代码。

下面以一个简单的示例看看 structural tree 的结构,示例代码如下

class C { 
	private int f; 
    void func() {
    }
}

代码对应的树结构如下

image.png

搜索上述代码的 StructuralRule 的代码如下

Field field: field.name == "f" and field.enclosingClass is [Class class: class.name == "C"]

其中 Field field: 类似于声明变量, : 后面试前面变量需要满足的条件,比如

field.name == "f"

这个就表示 fieldnamef ,规则后续使用 and 表示条件,然后通过 field.enclosingClass 获取到这个字段位于的class[...] 类似于定义一个变量,其返回值为满足条件的对象

[Class class: class.name == "C"]

上面的语句表示 [] 会返回 类名为 C 的 Class 对象

field.enclosingClass is [Class class: class.name == "C"]

这条语句的作用就是限制 field 所在的类的类名为 C ,其实 StructuralRule 的作用和使用方式和Codeql非常相似,主要就是利用逻辑表达式(and, or...)来匹配代码的特定元素。

下面介绍CharacterizationRule的使用,首先定义 source

<CharacterizationRule formatVersion="19.10" language="cpp">
    <RuleID>EE5D-4B1D-A798-4D1B5E081112</RuleID>
    <StructuralMatch>
        <![CDATA[
            FunctionCall fc:
                fc.name contains "get_user_input_str" 
        ]]>                
    </StructuralMatch>
    <Definition>
        <![CDATA[
            TaintSource(fc, {+PRIVATE})
        ]]>                
    </Definition>
</CharacterizationRule>

其中 StructuralMatch 使用 StructuralRule 的语法来匹配代码,然后在 Definition 里面可以使用一些API(比如TaintSource)和匹配到的代码元素来标记污点跟踪相关的熟悉,比如污点源、Sink点等,这里要注意一点:Definition 中可以访问到 StructuralMatch 中声明的所有变量,不论是通过 : 还是通过 [] 声明。

上述规则的作用就是

  1. 首先通过 StructuralMatch 匹配到 get_user_input_str 的函数调用对象 fc.
  2. 然后在 Definition ,使用 TaintSource 设置 fc 为污点源,污点标记为 PRIVATE.

sink 点的设置

<CharacterizationRule formatVersion="3.12" language="cpp">
    <RuleID>EE905D4B-A03D-49B2-83E4-4EE043411223</RuleID>
    <VulnKingdom>Input Validation and Representation</VulnKingdom>
    <VulnCategory>System RCE</VulnCategory>
    <DefaultSeverity>4.0</DefaultSeverity>
    <Description><![CDATA[]]></Description>
    <StructuralMatch>
        <![CDATA[
            FunctionCall fc:
                fc.name contains "system" and  fc.arguments[0] is [Expression e:]
        ]]>                
    </StructuralMatch>
    <Definition>
        <![CDATA[
            TaintSink(e, [PRIVATE])
        ]]>                
    </Definition>
</CharacterizationRule>

规则解释如下:

  1. 首先使用 StructuralMatch 匹配 fcsystem 的函数调用, efc 的第0个参数
  2. 然后在 Definition 使用 TaintSink 设置 esink点,污点标记为 PRIVATE.

这样就表示如果 system 函数调用的第 0 个参数为污点数据且污点数据中包含 PRIVATE 标记,就会把这段代码爆出来。

其他的规则(函数建模,clean_data函数)也是类似这里不再介绍,最终扫描结果如下图:

image.png

在开发 Structural 相关规则时可以在分析时使用 -Ddebug.dump-structural-tree 把代码的 structural tree 打印出来,然后我们根据树的结构就可以比较方便的开发规则,完整命令行如下

/home/hac425/sca/fortify/bin/sourceanalyzer -no-default-rules -rules hello_array.xml -b fortify-example -scan -f fortify-example.fpr -D com.fortify.sca.MultithreadedAnalysis=false  -Ddebug.dump-structural-tree 2> tree.tree

打印出来的示例如下

image.png

根据树状结构就可以写出匹配 global_array[user] 的代码如下:

ArrayAccess aa: aa.index  is [VariableAccess va:va.name == "user"]

引用计数漏洞

本节相关代码

https://github.com/hac425xxx/sca-workshop/blob/master/fortify-example/ref_rules/

漏洞代码

int ref_leak(int *ref, int a, int b)
{
    ref_get(ref);
    if (a == 2)
    {
        puts("error 2");
        return -1;
    }
    ref_put(ref);
    return 0;
}

int ref_dec_error(int *ref, int a, int b)
{
    ref_get(ref);
    if (a == 2)
    {
        puts("ref_dec_error 2");
        ref_put(ref);
    }
    ref_put(ref);
    return 0;
}

ref_leak 的 漏洞是当 a=2 时会直接返回没有调用 ref_put 对引用计数减一,漏洞模型:在某些存在 return 的条件分支中没有调用 ref_put 释放引用计数。

ref_dec_error 的漏洞是在特定条件下会对引用计数减多次。

这种类型漏洞适合使用 ControlflowRule 来查询对应的漏洞,对于规则如下

<ControlflowRule formatVersion="3.4" language="cpp">
    <RuleID>1650899A-908F-4301-B67A-D08E8E331122</RuleID>
    <VulnKingdom>API Abuse</VulnKingdom>
    <VulnCategory>Ref Leak</VulnCategory>
    <DefaultSeverity>3.0</DefaultSeverity>
    <Description><![CDATA[]]></Description>
    
    <FunctionIdentifier id="ref_put">
        <FunctionName>
            <Pattern>ref_put</Pattern>
        </FunctionName>
    </FunctionIdentifier>
    
    <FunctionIdentifier id="ref_get">
        <FunctionName>
            <Pattern>ref_get</Pattern>
        </FunctionName>
    </FunctionIdentifier>
    
    <PrimaryState>ref_add</PrimaryState>
    <Definition>
        <![CDATA[
            state start (start);
            state ref_add;
            state ref_dec;
            state no_leak;
            state checked;
            state leak (error) : "ref.leak";
            state double_dec (error): "ref dec 2";

            var p;
            start -> ref_add { $ref_get(p) }

            ref_add -> ref_dec { $ref_put(p) }
            ref_dec -> double_dec { $ref_put(p) }
            ref_dec -> checked { #return() }
            ref_add -> leak { #return() }
        ]]>
    </Definition>
</ControlflowRule>

首先 FunctionIdentifier 匹配 ref_putref_get 两个函数,然后通过 Definition 定义规则

state start (start);
state ref_add;
state ref_dec;
state no_leak;
state checked;
state leak (error) : "ref.leak";
state double_dec (error): "ref dec 2";

var p;
start -> ref_add { $ref_get(p) }

ref_add -> ref_dec { $ref_put(p) }
ref_dec -> double_dec { $ref_put(p) }
ref_dec -> checked { #return() }
ref_add -> leak { #return() }

规则的解释如下:

  1. 首先通过 state xxx 定义一些状态,其中 (start) 表示状态时初始状态,(error) 表示对应状态为错误状态,只要代码进入了错误状态就会在扫描结果中呈现, var 用于定义一个临时变量。
  2. 在规则中使用 $func_id 来引用之前使用 FunctionIdentifier 匹配到的函数。
  3. start -> ref_add { $ref_get(p) } 表示从 start 状态 进入 ref_add 状态的条件是调用了 ref_get 函数,入参为 p
  4. ref_add -> leak { #return() } 表示从 ref_add 状态 进入 leak 状态的条件是函数直接 return 返回了。
  5. ref_add -> ref_dec { $ref_put(p) } 表示代码在 ref_add 状态情况下对 p 调用了 ref_put 后就会进入 ref_dec,即对引用计数减1.
  6. 如果在 ref_dec 状态从函数返回,就表示函数没有问题。
  7. 如果在 ref_dec 状态下再次调用 ref_put(p) 则会进入 double_dec,会在扫描结果中呈现。

其他的tips

Fortify自带的规则是加密过的的,我们可以根据已有的一些研究对其解密,然后参考官方的规则来开发新的规则

https://www.52pojie.cn/thread-783946-1-1.html

可以查看 fortify-sca-20.1.1.0007.jar 里面的 com.fortify.sca.nst.nodes 包里面的类,这些类表示的是fortify语法树的各个节点,可以通过对应类的方法知道在结构化规则中可以访问的方法和函数。

image.png

总结

Fortify相比codeql的优势在于:

  1. 商用工具,拥有许多预设规则,比较成熟。
  2. 规则开发模式比较局限,但是对于某些特定场景的规则开发相对简单。
  3. 适合大规模规则的扫描。

codeql 的语法非常灵活,可以灵活运用匹配出各种代码片段,支持对大部分语法元素应用污点分析,比如支持设置数组索引位置为Sink点,经过各种尝试,发现fortify不支持。

参考

https://bbs.huaweicloud.com/blogs/104311

https://tech.esvali.com/mf_manuals/html/sca_ssc/

https://paper.seebug.org/papers/old_sebug_paper/books/Fortify/rules-schema/

posted @ 2021-03-28 16:38  hac425  阅读(999)  评论(0编辑  收藏  举报