codeql 学习笔记


阅读数: 次   

学习文档

https://codeql.github.com/docs/codeql-language-guides/codeql-for-cpp/

学习文章

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

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

https://mp.weixin.qq.com/s?__biz=MzI0MDY1MDU4MQ==&mid=2247496637&idx=1&sn=ac15882cb557cbc2c4450497d16824a8&chksm=e9152387de62aa916fde98a3fb3b51a13e90aa165b76acb458c1120452dacdc485905984920d&scene=21#wechat_redirect

基础

安装方法

下载地址

https://github.com/github/codeql-cli-binaries/releases

且安装ql

https://github.com/Semmle/ql

目录结构

image-20210324132445914

然后按照 vscode 插件

image-20210324132454727

使用准备

学习利用的 测试代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <string.h>

char read_byte()
{
    return 1;
}


int example_1()
{
    int x = read_byte();
    char buf[20];
    memset(buf, 0xaa, x);
}


int main()
{
    example_1();
}

需要安装 对应的数据库。

1
./codeql/codeql database create --language=cpp -c "gcc hello.c -o hello" ./hello_codedb

编译且 创建了 hello 文件 -c 指定编译代码需要执行的命令命令

image-20210328204527323

打开对应的 hello_codedb 数据库

image-20210328210439349

选着刚刚的 hello_codedb 文件。

且我们需要选中这个 db 文件

image-20210328210548895

接着我们需要在对应的 语言中创建对应的 hello.ql 文件用于查询

（因为 我们需要 import cpp 所以我们需要在对应的目录下创建 里面有个 cpp.ql 文件

我的对应目录 codeql/ql/cpp/ql/src

image-20210328210821673

测试

hello.ql 内容

测试

1
select "Hello World!"

运行结果

image-20210328211718996 
1
2
3
import cpp
from FunctionCall fc
select fc.getTarget().getQualifiedName(), fc
image-20210328211107488

运行结果

image-20210328211809077

基础内容

    • import 引入ql 文件。
    • from 限定基础范围，且可以对其简单命名
    • where 限制 ql 查询范围 添加限制
    • select 搜索内容 进行查询

库内容

Macro 对应的 宏相关的包

Function 对应 函数调用

FunctionCall 涵盖所有的函数调用，因此我们可以通过该对象来获取特定函数被调用的位置

语句分析

在 codeql 中我们也可以定义属于自己的 谓语 predicate （函数），利用 predicate 来定义

结构为

1
2
3
4
predicate name(type arg)
{
  statements
}

包含

对应的关键字 predicate （无返回值）或则利用 返回值类型定义对应的 谓语 （函数）

谓语（函数）的名称 name

谓语（函数）的参数 type arg

谓语（函数）的主题语句

谓语

对于没有返回值的谓语（函数），我们利用 predicate 来定义对应的谓语（函数）类型

对应有返回值的谓语（函数），这里我们利用返回的 对应的 类型来定义 int 等，且这里利用的返回保存在 result 中

对于我们谓语（函数）中的参数，他的数据类型必须是有限的，函数中必须限定他的范围

如

1
2
3
4
5
6
7
8
9
import cpp
int add(int x,int y){
    result = x+y
}

from int x, int y
where y = 42 and x =10
select add(x,y)

这样调用的时候会报错说我们的数据没有限定对应的范围

image-20210329123517732

如果想要能够利用这个函数。

我们要限定对应的 x y 的范围 可以利用 bindingset 来修饰我们的 x 和 y

1
2
3
4
5
6
7
8
9
10
import cpp
bindingset[x,y ]
int add(int x,int y){
    result = x+y
}

from int x, int y
where y = 42 and x =10
select add(x,y)

从而能够成功

image-20210329122829557

查询

可以利用 as 来修改对应的 参数名字

对于我们的 查询可以利用 order by 来进行排序

类

在 Codeql 中 一个类的创建，其实不是创建一个新的对象，而是标识特定的一类数据集合。

包含

关键字 class

类名 且类名开头字母 必须为 大写

扩展类型 （类名后）如 extends int 即boolean、float、int、string以及date。

类主体

例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class OneTwoThree extends int {
  OneTwoThree() { // characteristic predicate
    this = 1 or this = 2 or this = 3
  }
 
  string getAString() { // member predicate
    result = "One, two or three: " + this.toString()
  }

  predicate isEven() { // member predicate
    this in [1 .. 2] // 
  }
}

from OneTwoThree i 
where i = 1 or i.getAString() = "One, two or three: 2"
select i
// 输出1和2

特征谓语 类似于c++ 的构造函数

1
2
3
OneTwoThree() { // characteristic predicate
  this = 1 or this = 2 or this = 3
}

this变量表示的是当前类中所包含的数据集合。与result变量类似，this同样是用于表示数据集合直接的关系。

成员谓语 类似于 对应的 基础函数

1
2
3
string getAString() { // member predicate
  result = "One, two or three: " + this.toString()
}

这里可以对传入的数据调用这个函数，且能够函数拼接

类似

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class OneTwoThree extends int {
    OneTwoThree() { // characteristic predicate
      this = 1 or this = 2 or this = 3
    }
   
    string getAString() { // member predicate
      result = "One, two or three: " + this.toString()
    }
  
    predicate isEven() { // member predicate
      this in [1 .. 2] // 
    }
  }
  
  from OneTwoThree i 
  where i = 1 or i.getAString() = "One, two or three: 2"
  select 1.(OneTwoThree).getAString() ,1.(OneTwoThree).getAString().toUpperCase()

返回结果

image-20210329133359791

直接调用 getAString 方法，且可以拼接 toUpperCase() 函数来实现 讲返回字符串大写

类字段

从而创建字段

1
2
3
4
5
6
7
8
9
10
11
12
13
class SmallInt extends int {
    SmallInt() { this = [1 .. 10] }
  }
  
  class DivisibleInt extends SmallInt {
    SmallInt divisor;   // declaration of the field `divisor`
    DivisibleInt() { this % divisor = 0 }
  
    SmallInt getADivisor() { result = divisor }
  }
  
  from DivisibleInt i
  select i, i.getADivisor()

需要注意的是，

  • 每个类都不能继承自己
  • 不能继承final类
  • 不能继承不相容的类

且对于类 也存在 abstract 修饰的抽象类

可以一次继承多个类型

数据流

数据流分析用于分析 变量在代码中各个点的值，在 CodeQL 中，你可以对本地数据流和全局数据流建立模型。

局部数据流

在一个单独的函数中的数据流，简单且比全局更精确。

局部数据流的相关库在 DataFlow 模块中，它被定义为 Node 类，表示数据可以流经的任何元素。Node 被分为表达式 (ExprNode) 和参数 (ParameterNode) 两种。使用成员谓词 asExpr 和 asParameter 可以在数据流 node 和表达式 / 参数 node 之间进行映射

1
2
3
4
5
6
7
8
9
class Node {
  /** 获取代码中该节点相应的表达式(如果有的话). */
  Expr asExpr() { ... }

  /** 获取代码中该节点相应的参数(如果有的话). */
  Parameter asParameter() { ... }

  ...
}

或则使用

1
2
3
4
5
6
7
8
9
/**
 * Gets the node corresponding to expression `e`.
 */
ExprNode exprNode(Expr e) { ... }

/**
 * Gets the node corresponding to the value of parameter `p` at function entry.
 */
ParameterNode parameterNode(Parameter p) { ... }

注意：参数结点ParameterNode指的是当前函数参数的数据流结点。

谓词localFlowStep(Node nodeFrom, Node nodeTo)可以分析出从nodeFrom到nodeTo中的元素之间数据流动的方式。该谓词可以通过使用符号+和*来进行递归调用，或者使用预定义好的递归谓词localFlow。

例如，从零个或多个局部步骤中查找从参数 sourece 到表达式 sink 的污染传播：

1
TaintTracking::localTaint(DataFlow::parameterNode(source), DataFlow::exprNode(sink))

在 codeql 中 如果我们想查询一个 基本操作的 + 加法运算

1
2
3
x = x+1;
x += 1;
x++;

我们可以直接利用 AddInstruction 直接找到 （根据编译的中间代码 IR 进行查找

CodeQL U-Boot 挑战

https://lab.github.com/GitHubtraining/codeql-u-boot-challenge-(cc++)

拷贝创建的 code-uboot 文件

git clone https://github.com/0xC4m3l-jiang/codeql-uboot.git

拷贝 vscode-codeql-starter

git clone --recursive https://github.com/github/vscode-codeql-starter.git

下载对应 u-boot 库

U-Boot CodeQL database 并解压

运行环境配置

首先将 codeql-uboot 放入到 vscode-codeql-starter 文件夹下

image-20210330145730148

然后 利用 vscode 点击 文件->打开工作区 选中 vscode-codeql-starter 文件夹中的 vscode-codeql-starter.code-workspace 。

从而打开工作区

然后在 vscode 里面的 codeql 中 选中 u-boot 数据库

image-20210330145950034

这样就配置好了环境

image-20210330161031991

Challenge C++

函数查找

利用 codeql 查询里面存在的函数

1
2
3
4
5
import cpp

from Function f
where f.getName() = "strlen"
select f, "a function named strlen"

通过这个语句我们可以查询到我们的 u-boot 里面存在的对应的函数且可以通过点击确定他的位置

image-20210330162543276

宏查询

利用 Macro 类进行对 u-boot 中宏的查询。这里我们要查询 ntohl, ntohll, ntohs

这里 codeql 可以利用 正则匹配

1
2
3
4
5
import cpp

from Macro m
where m.getName().regexpMatch("ntoh(s|l|ll)")
select m
image-20210330162518740

两个变量查询调用该函数的位置

利用 from 一次创建多个变量

在 where 中添加多个 多个条件进行查询，每个条件中利用 and 进行一个连接

1
2
3
4
5
6
7
import cpp

from FunctionCall fc, Function f
where 
    fc.getTarget() = f and
    f.getName() = "memcpy"
select fc
image-20210330163346012

FunctionCall将会涵盖所有的函数调用，因此我们可以通过该对象来获取特定函数被调用的位置。

Function 对应 函数调用

查看宏的顶层表达

通过 MacroInvocation 这个类来查询 “ntohs” 等宏的调用，并通过 getExpr() 这个方法进行宏的展开，得到相应的代码片段。

1
2
3
4
5
import cpp

from MacroInvocation mi
where mi.getMacro().getName().regexpMatch("ntoh(s|l|ll)")
select mi.getExpr()

实现一个类进行查找

一个类对应一个 数据集合

这里我们可以利用类来限定我们的查询的值

对于一个量的查询 exists 量创建一个临时变量

1
2
3
4
5
6
7
8
9
10
11
12
import cpp

class NetworkByteSwap extends Expr{
    NetworkByteSwap(){
        exists(MacroInvocation mi |
            mi.getMacroName().regexpMatch("ntoh(s|l|ll)") and
            this = mi.getExpr())
    }
}

from NetworkByteSwap nb
select nb

这里创建 NetworkByteSwap 类 且 继承了 Expr 里面的 特征谓语 NetworkByteSwap() 中限定了。

且 this 指向我们这个集合的内容

污点分析

https://codeql.github.com/docs/codeql-language-guides/analyzing-data-flow-in-cpp/

利用了 数据流有关知识

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import cpp
import semmle.code.cpp.dataflow.TaintTracking
import DataFlow::PathGraph

// 设置与网络交换相关的类
class NetworkByteSwap extends Expr {
  NetworkByteSwap() {
    exists(MacroInvocation mi |
      mi.getMacroName().regexpMatch("ntoh(s|l|ll)") and
      this = mi.getExpr()
    )
  }
}

// 这个是与污点分析有关的类
class Config extends TaintTracking::Configuration {
  Config() { this = "NetworkToMemFuncLength" }
// 覆盖原先的isSource. 该谓语用于表示满足控制流源头的表达式.
// isSource-定义污物可能从何处流出
  override predicate isSource(DataFlow::Node source) { source.asExpr() instanceof NetworkByteSwap }

// isSink-定义污点可能流入的地方
  override predicate isSink(DataFlow::Node sink) {
    exists(FunctionCall call |
      call.getTarget().getName() = "memcpy" and
      sink.asExpr() = call.getArgument(2) and
      not call.getArgument(1).isConstant()
    )
  }
}

from Config cfg, DataFlow::PathNode source, DataFlow::PathNode sink
where cfg.hasFlowPath(source, sink)
select sink, source, sink, "Network byte swap flows to memcpy"

CodeQL securityLab 挑战

分析 codeql 语句

Github 链接

https://github.com/github/securitylab

下载后可以添加到 vscode-codeql-starter 中

git clone https://github.com/github/securitylab.git

准备

首先我们学习

securitylab/tree/main/CodeQL_Queries/cpp/MinIntNegate

下的实例 ql 语句

MinIntNegate

1
codeql database create MinIntNegateDB --language=cpp --command="g++ -c test.cpp"
image-20210331103316024

然后将生成的 MinIntNegateDB 加入到 VSCODE 的 codeql 数据库中

image-20210331103445313

漏洞模式

有符号数的判断问题

下面的代码是对 <0 的数将其转化为 正数的操作

但是如果 x = 0x80000000 这样的清空他一样为 0 这时候改变 x 的符号不会真的改变 x 的正负，也就是说 x 的值还是为 0x80000000 然而这里我们对应的返回值类型是无符号类型，那么返回的值就会是一个很大的正数。

1
2
3
4
5
6
unsigned int test000(int x) {
  if (x < 0) {
    x = -x;
  }
  return x;
}

编写 codeql 查询上述类型漏洞

查询规则说明

这里用到 Guards库

该类表示用于制定控制流决策的布尔值。

根据上面的实例代码，我们知道 存在漏洞的 x参数，首先会有一个 if 语句的判定 x < 0

  1. 左边为 变量(x)
  2. 右边为实数(0)
  3. 中间有一个操作符逻辑运算。

然后是判断 if 语句后

  1. 存在一个基本块
  2. 基本块中有 - 负号计算
  3. 且 - 负号控制我们的 变量 (x)

测试1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import cpp
import semmle.code.cpp.controlflow.Guards

// Find this pattern:
//
// ```
// if (x < 0) {
//   x = -x;
// }
// ```
//
// If the value of `x` is `0x80000000` then this will not make the value of `x` positive.
from GuardCondition guard, BasicBlock block, UnaryMinusExpr unaryMinus, Variable v, Expr use
where
 // 获得左边元素 为变量
  guard.(LTExpr).getLeftOperand() = v.getAnAccess() and
  // 获得右边操作数  为0
  guard.(LTExpr).getRightOperand().getValue().toInt() = 0 and
  // 管理操作 基本块
  guard.controls(block, true) and
  // 基本块中 存在 一元负表达式
  block.contains(unaryMinus) and
  // 一元负表达式 控制 变量
  unaryMinus.getOperand() = v.getAnAccess()
  // 进行查询 $@ 为格式化字符
select unaryMinus, "If the value of $@ is MinInt then this assignment will not make it positive", v,
  v.getName()

但是我们会发现，这里我们codeql 查询的内容中

image-20210401101303676

左右两边的 参数不一样说明查询不准确这个值查询的 对应变量的 参数名是否一样，没有匹配到是否是同一个类里面的变量。

因为这里我们利用的是 Variable v 变量类型

测试2

这里我们要修改 Variable v 为 LocalScopeVariable 局部变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import cpp
import semmle.code.cpp.controlflow.Guards

// The previous query had an incorrect result at test.cpp, line 20:
//
//   if (s->myfield < 0) {
//     s->myfield = -t->myfield;
//   }
//
// The problem is that the query used `Variable`, which includes fields.
// So here we restrict the query to use `LocalScopeVariable` instead.
from
  GuardCondition guard, BasicBlock block, UnaryMinusExpr unaryMinus, LocalScopeVariable v, Expr use
where
  guard.(LTExpr).getLeftOperand() = v.getAnAccess() and
  guard.(LTExpr).getRightOperand().getValue().toInt() = 0 and
  guard.controls(block, true) and
  block.contains(unaryMinus) and
  unaryMinus.getOperand() = v.getAnAccess()
select unaryMinus, "If the value of $@ is MinInt then this assignment will not make it positive", v,
  v.getName()

这次查到了两个数据

image-20210401102643816

而且 还过滤掉了 s->myfield = -s->myfield; 这个正确的情况 这个情况为一个 全局变量所以不能被查询到。

测试3

因为我们还要查找 s->myfield = -s->myfield; 所以我们需要查询下全局变量

这里可以利用 globalValueNumber 获取表达式的全局值编号

这个函数来对 运算符左右两边的 表达式进行一个处理 然后判断是否相等。这样就能确定 是否能够使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import cpp
import semmle.code.cpp.controlflow.Guards
import semmle.code.cpp.valuenumbering.GlobalValueNumbering

// The previous query, 01_MinIntNegate, eliminated a bad result
// from 00_MinIntNegate, but it also lost a good result.
// The missing result is test.cpp, line 14:
//
//   if (s->myfield < 0) {
//     s->myfield = -s->myfield;
//   }
//
// The problem is that `s->myfield` is not a `LocalScopeVariable`.
// The solution is to use the GlobalValueNumbering library, which
// is a more general way to find expressions that compute the same
// value.
from GuardCondition guard, BasicBlock block, UnaryMinusExpr unaryMinus, Expr use1, Expr use2
where
  guard.(LTExpr).getLeftOperand() = use1 and
  guard.(LTExpr).getRightOperand().getValue().toInt() = 0 and
  guard.controls(block, true) and
  block.contains(unaryMinus) and
  unaryMinus.getOperand() = use2 and
  globalValueNumber(use1) = globalValueNumber(use2)
select unaryMinus, "If the value of $@ is MinInt then this assignment will not make it positive",
  use2, use2.toString()

这样我们就能查询到对应的 左右相同的了

image-20210401111753044

这样我们就能查到对应的内容了，但是这样我们只查询到 小于的时候的比较这里没有 大于比较的时候

这里说明我们还要加 条件实现

测试4

写一个谓语（函数）来进行判断 等于或则大于

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import cpp
import semmle.code.cpp.controlflow.Guards
import semmle.code.cpp.valuenumbering.GlobalValueNumbering

// The previous query only worked for `x < 0` and not for the
// equivalent `0 > x`. Its easier to handle both if we refactor
// the logic into a separate predicate.

/** Holds if `cond` is a comparison of the form `lhs < rhs`. */
predicate lessThan(Expr cond, Expr lhs, Expr rhs) {
  cond.(LTExpr).getLeftOperand() = lhs and
  cond.(LTExpr).getRightOperand() = rhs
  or
  cond.(GTExpr).getLeftOperand() = rhs and
  cond.(GTExpr).getRightOperand() = lhs
}

from
  GuardCondition guard, BasicBlock block, UnaryMinusExpr unaryMinus, Expr use1, Expr use2, Expr zero
where
// 通过这个谓语 匹配 大于和小于 
  lessThan(guard, use1, zero) and
// 其他匹配一样
  zero.getValue().toInt() = 0 and
  guard.controls(block, true) and
  block.contains(unaryMinus) and
  unaryMinus.getOperand() = use2 and
// 全局值编号
  globalValueNumber(use1) = globalValueNumber(use2)
select unaryMinus, "If the value of $@ is MinInt then this assignment will not make it positive",
  use2, use2.toString()

利用 ComparisonOperation.qll 里面的谓语 用于匹配 大于比较 或则小于比较

image-20210401140114296

测试5

现在我们添加一个新的内容，让其也支持 大于等于 小于等于

利用 ComparisonOperation.qll 里面谓语

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import cpp
import semmle.code.cpp.controlflow.Guards
import semmle.code.cpp.valuenumbering.GlobalValueNumbering

// Let us also add support for <= and >=.

/**
 * Holds if `cond` is a comparison of the form `lhs < rhs`.
 * `isStrict` is true for < and >, and false for <= and >=.
 */
predicate lessThan(Expr cond, Expr lhs, Expr rhs, boolean isStrict) {
  cond.(LTExpr).getLeftOperand() = lhs and
  cond.(LTExpr).getRightOperand() = rhs and
  isStrict = true
  or
  cond.(GTExpr).getLeftOperand() = rhs and
  cond.(GTExpr).getRightOperand() = lhs and
  isStrict = true
  or
  cond.(LEExpr).getLeftOperand() = lhs and
  cond.(LEExpr).getRightOperand() = rhs and
  isStrict = false
  or
  cond.(GEExpr).getLeftOperand() = rhs and
  cond.(GEExpr).getRightOperand() = lhs and
  isStrict = false
}

from
  GuardCondition guard, BasicBlock block, UnaryMinusExpr unaryMinus, Expr use1, Expr use2, Expr zero
where
  lessThan(guard, use1, zero, _) and
  zero.getValue().toInt() = 0 and
  guard.controls(block, true) and
  block.contains(unaryMinus) and
  unaryMinus.getOperand() = use2 and
  globalValueNumber(use1) = globalValueNumber(use2)
select unaryMinus, "If the value of $@ is MinInt then this assignment will not make it positive",
  use2, use2.toString()

测试6

这里利用的递归进行查找的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import cpp
import semmle.code.cpp.controlflow.Guards
import semmle.code.cpp.valuenumbering.GlobalValueNumbering

// The previous query added support for <= and >=, but failed to
// find any new results. That is because the comparison is 0 <= x,
// so the operands are the wrong way around. We can solve this by
// adding a recursive predicate which swaps them.

/**
 * Holds if `cond` is a comparison of the form `lhs < rhs`.
 * `isStrict` is true for < and >, and false for <= and >=.
 */
predicate lessThan(Expr cond, Expr lhs, Expr rhs, boolean isStrict) {
  cond.(LTExpr).getLeftOperand() = lhs and
  cond.(LTExpr).getRightOperand() = rhs and
  isStrict = true
  or
  cond.(GTExpr).getLeftOperand() = rhs and
  cond.(GTExpr).getRightOperand() = lhs and
  isStrict = true
  or
  cond.(LEExpr).getLeftOperand() = lhs and
  cond.(LEExpr).getRightOperand() = rhs and
  isStrict = false
  or
  cond.(GEExpr).getLeftOperand() = rhs and
  cond.(GEExpr).getRightOperand() = lhs and
  isStrict = false
}

/**
 * Holds if `cond` is a comparison of the form `lhs < rhs`.
 * `isStrict` is true for < and >, and false for <= and >=.
 * `branch` is true if the comparison is true and false if it is not.
 */
predicate lessThanWithNegate(Expr cond, Expr lhs, Expr rhs, boolean isStrict, boolean branch) {
	// true and lessThan 运行判断是否还能继续向下处理 调用 谓语 lessThan 判断是否
  branch = true and lessThan(cond, lhs, rhs, isStrict)
  or
  // (x < y) == !(y <= x)
  // 这里将其转化为 去掉 ! 取反的后的比较结构。
  lessThanWithNegate(cond, rhs, lhs, isStrict.booleanNot(), branch.booleanNot())
}

from
  GuardCondition guard, BasicBlock block, UnaryMinusExpr unaryMinus, Expr use1, Expr use2,
  Expr zero, boolean branch
where
  lessThanWithNegate(guard, use1, zero, _, branch) and
  zero.getValue().toInt() = 0 and
  guard.controls(block, branch) and
  block.contains(unaryMinus) and
  unaryMinus.getOperand() = use2 and
  globalValueNumber(use1) = globalValueNumber(use2)
select unaryMinus, "If the value of $@ is MinInt then this assignment will not make it positive",
  use2, use2.toString()

调用后

image-20210401150349516

测试7

这里还有一种情况可能

image-20210401152600061

现在外存在一个 bool 值赋值，然后在带入到了 if 语句里面判断是否在一个基础块中，如果要查询这类值，我们需要进行污点流跟踪分析。

1
2
3
4
exists(Expr prev |
    DataFlow::localExprFlow(prev, cond) and
    lessThanWithNegate(prev, lhs, rhs, branch, isStrict)
  )

完整为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import cpp
import semmle.code.cpp.controlflow.Guards
import semmle.code.cpp.valuenumbering.GlobalValueNumbering
import semmle.code.cpp.dataflow.DataFlow

// Let us add local dataflow, so that we can also handle cases like this:
//
// ```
// bool b = x < 0;
// if (b) {
//   x = -x;
// }
// ```

/**
 * Holds if `cond` is a comparison of the form `lhs < rhs`.
 * `isStrict` is true for < and >, and false for <= and >=.
 */
predicate lessThan(Expr cond, Expr lhs, Expr rhs, boolean isStrict) {
  cond.(LTExpr).getLeftOperand() = lhs and
  cond.(LTExpr).getRightOperand() = rhs and
  isStrict = true
  or
  cond.(GTExpr).getLeftOperand() = rhs and
  cond.(GTExpr).getRightOperand() = lhs and
  isStrict = true
  or
  cond.(LEExpr).getLeftOperand() = lhs and
  cond.(LEExpr).getRightOperand() = rhs and
  isStrict = false
  or
  cond.(GEExpr).getLeftOperand() = rhs and
  cond.(GEExpr).getRightOperand() = lhs and
  isStrict = false
}

/**
 * Holds if `cond` is a comparison of the form `lhs < rhs`.
 * `isStrict` is true for < and >, and false for <= and >=.
 * `branch` is true if the comparison is true and false if it is not.
 */
predicate lessThanWithNegate(Expr cond, Expr lhs, Expr rhs, boolean isStrict, boolean branch) {
  branch = true and lessThan(cond, lhs, rhs, isStrict)
  or
  // (x < y) == !(y <= x)
  lessThanWithNegate(cond, rhs, lhs, isStrict.booleanNot(), branch.booleanNot())
  or
  // bool b = x < 0;
  // if (b) { ... }
  exists(Expr prev |
    DataFlow::localExprFlow(prev, cond) and
    lessThanWithNegate(prev, lhs, rhs, branch, isStrict)
  )
}

from
  GuardCondition guard, BasicBlock block, UnaryMinusExpr unaryMinus, Expr use1, Expr use2,
  Expr zero, boolean branch
where
  lessThanWithNegate(guard, use1, zero, _, branch) and
  zero.getValue().toInt() = 0 and
  guard.controls(block, branch) and
  block.contains(unaryMinus) and
  unaryMinus.getOperand() = use2 and
  globalValueNumber(use1) = globalValueNumber(use2)
select unaryMinus, "If the value of $@ is MinInt then this assignment will not make it positive",
  use2, use2.toString()

查询后得到的结果

image-20210401160230578

测试8

然后我们会发现我们的测试数据中还有其他的情况

image-20210401161149012

主要是 b = !(0 <= x) 这个我们需要先判断是否为 ! 修饰的类型，如果是在对其中的内容进行一个递归判断。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import cpp
import semmle.code.cpp.controlflow.Guards
import semmle.code.cpp.valuenumbering.GlobalValueNumbering
import semmle.code.cpp.dataflow.DataFlow

// The guards library automatically handles negations like this for us:
//
// ```
// if (!(x < 0)) {
//   // Do nothing.
// } else {
//   x = -x;
// }
// ```
//
// But it does not handle cases where dataflow is involved. For example:
//
// ```
// bool b = !(0 <= x);
// if (b) {
//   x = -x;
// }
// ```
//
// It is easy to fix by adding one more recursive clause to `lessThanWithNegate`.

/**
 * Holds if `cond` is a comparison of the form `lhs < rhs`.
 * `isStrict` is true for < and >, and false for <= and >=.
 */
predicate lessThan(Expr cond, Expr lhs, Expr rhs, boolean isStrict) {
  cond.(LTExpr).getLeftOperand() = lhs and
  cond.(LTExpr).getRightOperand() = rhs and
  isStrict = true
  or
  cond.(GTExpr).getLeftOperand() = rhs and
  cond.(GTExpr).getRightOperand() = lhs and
  isStrict = true
  or
  cond.(LEExpr).getLeftOperand() = lhs and
  cond.(LEExpr).getRightOperand() = rhs and
  isStrict = false
  or
  cond.(GEExpr).getLeftOperand() = rhs and
  cond.(GEExpr).getRightOperand() = lhs and
  isStrict = false
}

/**
 * Holds if `cond` is a comparison of the form `lhs < rhs`.
 * `isStrict` is true for < and >, and false for <= and >=.
 * `branch` is true if the comparison is true and false if it is not.
 */
predicate lessThanWithNegate(Expr cond, Expr lhs, Expr rhs, boolean isStrict, boolean branch) {
  branch = true and lessThan(cond, lhs, rhs, isStrict)
  or
  // (x < y) == !(y <= x)
  lessThanWithNegate(cond, rhs, lhs, isStrict.booleanNot(), branch.booleanNot())
  or
  // (!(x < y) == branch)  ==  ((x < y) == !branch)
  lessThanWithNegate(cond.(NotExpr).getOperand(), lhs, rhs, isStrict, branch.booleanNot())
  or
  // bool b = x < 0;
  // if (b) { ... }
  exists(Expr prev |
    DataFlow::localExprFlow(prev, cond) and
    lessThanWithNegate(prev, lhs, rhs, branch, isStrict)
  )
}

from
  GuardCondition guard, BasicBlock block, UnaryMinusExpr unaryMinus, Expr use1, Expr use2,
  Expr zero, boolean branch
where
  lessThanWithNegate(guard, use1, zero, _, branch) and
  zero.getValue().toInt() = 0 and
  guard.controls(block, branch) and
  block.contains(unaryMinus) and
  unaryMinus.getOperand() = use2 and
  globalValueNumber(use1) = globalValueNumber(use2)
select unaryMinus, "If the value of $@ is MinInt then this assignment will not make it positive",
  use2, use2.toString()

查询到 12 个结果

image-20210402103805400 image-20210402110301083

ChakraCore-bad-overflow-check

资料

https://help.semmle.com/QL/ql-training/cpp/bad-overflow-guard.html

思路

检测对应的整数溢出，整数溢出是在错误使用类型转换的时候所导致的。

有符号 与 无符号数进行运算会产生这样的问题等

例如

1
2
3
4
bool checkOverflow(unsigned short x, unsigned short y) {
  // BAD: comparison is always false due to type promotion
  return (x + y < x);  
}

x+y 会隐式转化为 int 类型。

1
2
3
bool checkOverflow(unsigned short x, unsigned short y) {
  return ((unsigned short)(x + y) < x);  // GOOD: explicit cast
}

这里强制转换 但是如果 x+y 大于16位 会讲更高位 截取掉可能会产生错误影响。

测试1

首先我们要找到 一个加法运算基本快，一个变量，一个关系运算（大于小于等）

1
2
3
4
5
6
7
8
9
10
import cpp

from AddExp a, variable v, RelationalOperation cmp
where 
// 加法中存在 v 变量
	a.getAnOprand() = v.getAnAccess() and
// cmp 关系运算的 参数是 为加法运行  和 变量v
	cmp.getAnOperand() = a and
	cmp.getAnOperand() = v.getAnAccess()
select cmp, "Overflow check."

测试2

然后我们现在已经能得到 （a+b<a）这样情况了。

但是还需要另一个先知条件，我们的 a 为16位的类型 也就是对应 4字节

这里我们可以设置一个 谓语来实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import cpp

// 大小为小于 16字节
predicate isSmall(Expr e) {
  e.getType().getSize() < 4
}

from AddExp a, variable v, RelationalOperation cmp
where 
// 加法中存在 v 变量
	a.getAnOprand() = v.getAnAccess() and
// cmp 关系运算的 参数是 为加法运行  和 变量v
	cmp.getAnOperand() = a and
	cmp.getAnOperand() = v.getAnAccess() and
// 加法运算中的每个 参数的值都是 小于 16 字节
	forall(Expr op | op = a.getAnOperand() | isSmall(op))
select cmp, "Overflow check."

测试3

加法运算的结果不执行强制类型转换，或者强转后的大小大于32位

这个条件会使得溢出检测算法无效，而这就是我们的目标所在。

1
2
3
4
5
6
7
8
9
10
11
12
import cpp

predicate isSmall(Expr e) { e.getType().getSize() < 4 }

from AddExpr a, Variable v, RelationalOperation cmp
where
  a.getAnOperand() = v.getAnAccess() and
  cmp.getAnOperand() = a and
  cmp.getAnOperand() = v.getAnAccess() and
  forall(Expr op | op = a.getAnOperand() | isSmall(op)) and
  not isSmall(a.getExplicitlyConverted())
select cmp, "Bad overflow check"

也有另一种写法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import cpp

/** Matches `var < var + ???`. */
predicate overflowCheck(LocalScopeVariable var, AddExpr add, RelationalOperation compare){
  /* 当前的relationalOperation，其左右两边分别是一个变量以及一个加法语句 */
  compare.getAnOperand() = var.getAnAccess() and
  compare.getAnOperand() = add and
  /* 同时这个变量还是加法语句中的一个操作数 */
  add.getAnOperand() = var.getAnAccess()
}

from LocalScopeVariable var, AddExpr add
where overflowCheck(var, add, _)    /* 获取可能存在溢出的点 */
  and var.getType().getSize() < 4   /* 当前的操作数大小要小于4字节 */
  and not add.getConversion+().getType().getSize() < 4 /* 限制加法的位数 >= 32 */
select add, "Overflow check on variable of type " + var.getUnderlyingType()

注意where语句中使用的一个通配符_，该通配符用于表示任何数据集。

Facebook_Fizz_CVE-2019-3560

资料

https://securitylab.github.com/research/facebook-fizz-CVE-2019-3560/

思路

该漏洞是由于PlaintextRecordLayer.cpp的+=第42行上的整数溢出引起的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
auto length = cursor.readBE<uint16_t>();
if (buf.chainLength() < (cursor - buf.front()) + length) {
  return folly::none;
}
length +=
    sizeof(ContentType) + sizeof(ProtocolVersion) + sizeof(uint16_t);
buf.trimStart(length);
continue;


void IOBuf::trimStart(std::size_t amount) {
    DCHECK_LE(amount, length_);
    data_ += amount;
    length_ -= amount;
  }

漏洞点为

这里的 auto length 的值是我们可控的然后下面的 if 语句比较，这里没有进行判断是否存在溢出，而是检测的 buf是否接收了 足够多的数据。

然后会有一个 length += 操作 这个操作里面 += 后可能会存在整数溢出从而造成 += 后值为 0

之后会将 length 作为参数传入 buf.trimStart(length); 函数

在这个函数中 会更具 amount 来根据偏移进行，从而造成 指针不被修改

在循环的下一次执行中，cursor会被设置为与当前循环相同的cursor，然后读取与当前循环相同的length，之后length继续溢出至0，buf的指针仍然没有被修改。如此循环往复，程序将陷入循环中无法跳出，这样便造成了拒绝服务攻击（DoS）。

测试1

首先，我们最基础的功能就是要找到在整个代码中，产生了 从较大类型到较小类型的所有转换 这个转换可能会存在溢出的风险，利用到 IR 包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import cpp
import semmle.code.cpp.ir.IR

/** Holds if `i` is a narrowing conversion. */
/** 判断是否存在类型转换 **/
predicate isNarrowingConversion(ConvertInstruction i) {
  i.getResultSize() < i.getUnary().getResultSize()
}

from ConvertInstruction conv, Type inputType, Type outputType
where
  isNarrowingConversion(conv) and
  inputType = conv.getUnary().getResultType() and
  outputType = conv.getResultType()
select conv, "Narrowing conversion from " + inputType + " to " + outputType + "."

这样能查出很多 可能存在因为类型转换而产生漏洞的地方。虽然存在可能利用的漏洞点，但是我们还需要知道的是，这些存在转换的内容是否是我们能控制的

测试2

我们已经设置好 能知道到 对应存在 类型转换的地方了，现在要做的就是找到这些函数中，哪儿些的参数是我们可控的输入

对于Fizz，事实证明，不受信任的输入是通过另一个名为Folly的Facebook库到达的。Folly将数据放在中IOBuf，然后由Fizz读取。因此，建模不受信任数据源的一种方法是找到IOBufFizz中s的所有用法。但是我们发现了另一种解决方案，该解决方案对于Fizz项目既简单又不那么具体：通过套接字发送数据时，通常以网络字节顺序发送数据。因此，通常需要使用或将网络数据转换为主机字节顺序。ntohs ntohl。

唯一的障碍是Fizz不使用ntohsand ntohl！而是使用Endian类。以下QL类标识Endian用于将网络字节顺序转换为主机的方法

查找所有Endian::big函数声明的QL代码

1
2
3
4
5
6
class EndianConvert extends Function {
  EndianConvert() {
    this.getName() = "big" and
    this.getDeclaringType().getName().matches("Endian")
  }
}

我们需要找到这个 Endian::big 的 FunctionCall 因为我们的恶意输入 就是从这个函数产生的

1
2
3
4
5
6
7
8
/**
 * Holds if `i` is an endianness conversion.
 * (A telltale sign of network data.)
 */
predicate isNetworkData(Instruction i) {
  i.(CallInstruction).getCallTarget().(FunctionInstruction).getFunctionSymbol() instanceof
    EndianConvert
}

接着我们要利用跟踪数据流的方法，我们要找到 是否有我们可控数据流能流入 存在 大位进制转小位进制 的地方。利用到 污点流量的 isSource isSink

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15



class Cfg extends TaintTracking::Configuration {
  Cfg() { this = "FizzOverflowIR" }

  /**
   * Holds if `source` is network data.
   */
  override predicate isSource(DataFlow::Node source) { isNetworkData(source.asInstruction()) }

  /** Holds if `sink` is a narrowing conversion. */
  override predicate isSink(DataFlow::Node sink) { isNarrowingConversion(sink.asInstruction()) }
}

最终为 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/**
 * @name Fizz Overflow
 * @description Narrowing conversions on untrusted data could enable
 *              an attacker to trigger an integer overflow.
 * @kind path-problem
 * @problem.severity warning
 */

import cpp
import semmle.code.cpp.ir.dataflow.TaintTracking
import semmle.code.cpp.ir.IR
import DataFlow::PathGraph

/**
 * The endianness conversion function `Endian::big()`.
 * It is Folly's replacement for `ntohs` and `ntohl`.
 */
class EndianConvert extends Function {
  EndianConvert() {
    this.getName() = "big" and
    this.getDeclaringType().getName().matches("Endian")
  }
}

/**
 * Holds if `i` is an endianness conversion.
 * (A telltale sign of network data.)
 */
predicate isNetworkData(Instruction i) {
  i.(CallInstruction).getCallTarget().(FunctionInstruction).getFunctionSymbol() instanceof
    EndianConvert
}

  /** Holds if `i` is a narrowing conversion. */
  predicate isNarrowingConversion(ConvertInstruction i) {
    i.getResultSize() < i.getUnary().getResultSize()
  }

  class Cfg extends TaintTracking::Configuration {
    Cfg() { this = "FizzOverflowIR" }

    /**
     * Holds if `source` is network data.
     */
    override predicate isSource(DataFlow::Node source) { isNetworkData(source.asInstruction()) }

    /** Holds if `sink` is a narrowing conversion. */
    override predicate isSink(DataFlow::Node sink) { isNarrowingConversion(sink.asInstruction()) }
  }

from
  Cfg cfg, DataFlow::PathNode source, DataFlow::PathNode sink, ConvertInstruction conv,
  Type inputType, Type outputType
where
  cfg.hasFlowPath(source, sink) and
  conv = sink.getNode().asInstruction() and
  inputType = conv.getUnary().getResultType() and
  outputType = conv.getResultType()
select sink, source, sink,
  "Conversion of untrusted data from " + inputType + " to " + outputType + "."

从而找到存在 漏洞的点

image-20210403160607847

libssh2_eating_error_codes

资料

https://blog.semmle.com/libssh2-integer-overflow/

https://github.com/Semmle/SecurityExploits/tree/446048470633bf0f8da9570d008d056dbaa28ea9/libssh2/out_of_bounds_read_kex_CVE-2019-13115

该漏洞是越界读取，可能导致远程信息泄露。使用libssh2连接到恶意SSH服务器时将触发该事件。libssh2接收uint32_t来自恶意服务器的，并且对此没有任何限制。然后，libssh2从所指定的偏移量中读取内存uint32_t。

思路

这里利用的是 调用一个函数后 返回有个 数值的比较 ，且函数返回的值 为 负数 却赋值给了 一个无符号数。

如

1
2
3
4
5
int f(){
  return -1;
}

unsigned res = f();

这样运行后 res 会变成一个很大的值

如果 这个 f() 函数目的是输出 一个大小，如果函数错误才会返回 -1 。这样就可能会存在一定的漏洞点，从而可以实现利用。

函数一 

1
2
3
4
int _libssh2_check_length(struct string_buf *buf, size_t len)
{
    return ((int)(buf->dataptr - buf->data) <= (int)(buf->len - len)) ? 1 : 0;
}

函数二

1
if((p_len = _libssh2_get_c_string(&buf, &p)) < 0)

测试1

这里我们要实现的目的为：

  1. 函数返回为 有符号数 （可以返回 为 -1）
  2. 赋值的参数为 无符号类型

满足条件1 可以找到 代码中 所有的 能返回 小于0 的地方

1
2
from ReturnStmt ret
where ret.getExpr().getValue().toInt() < 0

找到 对应的有返回值为 小于0 的地方后

我们向上找到 返回这个值的函数

1
2
3
4
5
6
7
8
import cpp

// Extend the previous query to also find calls to functions that sometimes
// return a negative integer constant.
from FunctionCall call, ReturnStmt ret
where
  ret.getExpr().getValue().toInt() < 0 and
  call.getTarget() = ret.getEnclosingFunction()

然后继续满足第二个 条件，返回值赋值给了 一个无参数类型的值。

1
2
3
4
5
6
7
8
9
10
import cpp

// Look for calls that are cast to unsigned, which means that the error
// code might be accidentally ignored.
from FunctionCall call, ReturnStmt ret
where
  ret.getExpr().getValue().toInt() < 0 and
  call.getTarget() = ret.getEnclosingFunction() and
  call.getFullyConverted().getType().getUnderlyingType().(IntegralType).isUnsigned()
  select call, ret

这样 就能进行查找了

这样就能查找到很多 瞒住这种情况的 时候。

测试2

但是后面我们会发现，这个还不能找到

如下 先返回给一个 有符号型，然后在赋值给一个 无符号数的情况。

1
2
int res1 = f();
unsigned int res2 = res1;

这个 情况，我们就需要

利用污点分析的。

1
2
3
4
5
6
7
8
9
10
11
12
13
import cpp
import semmle.code.cpp.dataflow.DataFlow

from FunctionCall call, ReturnStmt ret, DataFlow::Node source, DataFlow::Node sink
where
  ret.getExpr().getValue().toInt() < 0 and
  call.getTarget() = ret.getEnclosingFunction() and
  /* 数据流源头被设置为FunctionCall位置 */
  source.asExpr() = call and 
  /* 数据流终点被设置为存在类型转换的位置 */
  sink.asExpr().getFullyConverted().getType().getUnderlyingType().(IntegralType).isUnsigned() and
  DataFlow::localFlow(source, sink)
select source, sink

还有一种

1
2
3
4
5
6
7
8
9
10
11
12
13
import cpp
import semmle.code.cpp.dataflow.DataFlow
import semmle.code.cpp.rangeanalysis.SimpleRangeAnalysis

from Function f, FunctionCall call, ReturnStmt ret, DataFlow::Node source, DataFlow::Node sink
where call.getTarget() = f
and ret.getEnclosingFunction() = f
and ret.getExpr().getValue().toInt() < 0
and source.asExpr() = call
and DataFlow::localFlow(source, sink)
and sink.asExpr().getFullyConverted().getType().getUnderlyingType().(IntegralType).isUnsigned()
and lowerBound(sink.asExpr()) < 0
select sink

rsyslog_CVE-2018-1000140

资料

this snapshot db 文件下载

https://github.com/github/securitylab/tree/main/CodeQL_Queries/cpp/rsyslog_CVE-2018-1000140

https://help.semmle.com/QL/ql-training/cpp/snprintf.html#2

https://securitylab.github.com/research/librelp-buffer-overflow-cve-2018-1000140/

思路

这个 evc 的爆出 主要是因为 snprintf 这个 函数引起的

1
int snprintf(char *str, size_t size, const char *format, ...);

如果说我们使用的格式化字符串为”% s”，然后在后面的参数中传了一个很长的字符串进去 (大于 size)，那么多余的部分虽然会被截止掉，但是 snprintf 的返回值并不是 size 而是参数中字符串的长度。所以当我们这样使用 snprintf 的时候就有可能会造成溢出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

#define BUF_SIZE (32)
int main(int argc, char *argv[])
{
        char buffer[BUF_SIZE];
        size_t pos = 0;
        int i;
        for (i = 0; i < argc; i++)
        {
                pos += snprintf(buffer + pos, BUF_SIZE - pos, "%s", argv[i]);
                        // BUF_SIZE - pos may overflow
        }
}

其中 

1
2
3
4
5
printf("Hello %s!", name)
sprintf(buf, "Hello %s!", name)
snprintf(buf, n, "Hello %s!", name)
  	(1) 如果格式化后的字符串长度小于等于 size，则会把字符串全部复制到 str 中，并给其后添加一个字符串结束符 \0；
		(2) 如果格式化后的字符串长度大于 size，超过 size 的部分会被截断，只将其中的 (size-1) 个字符复制到 str 中，并给其后添加一个字符串结束符 \0，返回值为欲写入的字符串长度。

在漏洞中 snprintf 可能会返回 -1

测试1

首先我们要找到 这个 snprintf 这个函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import cpp

/*
 * Find all calls to `snprintf`.
 *
 * Note: you could do this first step with grep. However,
 * grep is less good because it doesn't know about macros.
 * For example, curl does this:
 *
 *   https://github.com/curl/curl/blob/87501e57f1c166cb250111af54e0470ab8b2099c/lib/curl_printf.h#L42
 */
from FunctionCall call
where call.getTarget().getName() = "snprintf"
select call

测试2

我们要找到 代码中 snprintf 这个函数的返回值被储存在变量的情况。

利用 where 中的 not call instanceof ExprInVoidContext 来记录

找到所有对应 snprintf 返回值作为变量赋值的地方

1
2
3
4
5
6
7
8
9
10
11
12
import cpp

/*
 * Only code that uses the result of snprintf might be vulnerable.
 * So restrict the results to those where snprintf is not used
 * in a "void context".
 */
from FunctionCall call
where call.getTarget().getName() = "snprintf"
and not call instanceof ExprInVoidContext
select call

测试3

然后我们需要了解到 这个漏洞的产生

是利用了 snprintf 的第3个参数 存在 %s 格式化字符串

我们要找到对应的地方

.regexpMatch("(?s).*%s.*") 利用正则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import cpp

/*
 * Only calls to `snprintf` with `%s` in the format specifier
 * are likely to be vulnerable. This is because other format
 * specifiers, like `%d` can only change the length of the output
 * string by a few character, but `%s` can change it a lot.
 * A `%s` specifier is also much more likely to enable an attacker
 * to overwrite the stack or heap with working shellcode.
 */
from FunctionCall call
where call.getTarget().getName() = "snprintf"
and not call instanceof ExprInVoidContext
and call.getArgument(2).getValue().regexpMatch("(?s).*%s.*")
select call

测试4

接着 返回值又一次作为了 snprintf 的第二个参数，所以我们根据这个条件过滤一下就可以了

这里需要利用 污点分析的方法来搜索

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import cpp
import semmle.code.cpp.dataflow.TaintTracking

/*
 * Look for dataflow from the result of `snprintf` back to
 * its size argument. Note that we no longer need the
 * `call instanceof ExprInVoidContext` clause, because this
 * is implied by the dataflow.
 */
from FunctionCall call, DataFlow::Node source, DataFlow::Node sink
where call.getTarget().getName() = "snprintf"
and call.getArgument(2).getValue().regexpMatch("(?s).*%s.*")
and TaintTracking::localTaint(source, sink)
and source.asExpr() = call
and sink.asExpr() = call.getArgument(1)
select call

这样 我们就能找到存在漏洞的地方了

可以添加 upperBound(call.getArgument(1).getFullyConverted()) 来显示 溢出的大小

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家