前言

之前看了下codeql java中source的定义,做代码审计的师傅都知道,source->sink的过程会有大量的传播链路,这个其实也是进行漏洞挖掘很重要的一部分,当前的很多AST工具其实就是这种传播链路不够完善,从而很多漏洞会存在漏报的情况;当然这个不够完善很多和具体业务和AST的设计有关。

这里使用codeql版本V2.22.1,2.22版本应该差别都不大。对于当前这个版本我们都知道创建自定义检测规则一般是下面这种:

import semmle.code.java.dataflow.FlowSources
private import semmle.code.java.dataflow.TaintTracking
import BaseInjectionFlow::PathGraph



module BaseFlowConfig implements DataFlow::ConfigSig {
  predicate isSource(DataFlow::Node source) { source instanceof ActiveThreatModelSource }

  predicate isSink(DataFlow::Node sink) { sink instanceof ceshiServiceSink }

  predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2) {
    none()
  }

  predicate observeDiffInformedIncrementalMode() { any() }
}


module BaseInjectionFlow = TaintTracking::Global<BaseFlowConfig>;



from BaseInjectionFlow::PathNode source, BaseInjectionFlow::PathNode sink
where BaseInjectionFlow::flowPath(source, sink)
select sink.getNode(), source, sink, "cccccc", source.getNode(),
  "this user input"

可以理解上面就是一个通用模版,其中上面module BaseFlowConfig implements DataFlow::ConfigSig这里只是设置了一个通用的数据流分析,但是让这个数据流分析具备污点分析、污点出传播能力的是module BaseInjectionFlow = TaintTracking::Global<BaseFlowConfig>;这个配置;

TaintTracking::Global的定义

TaintTracking中defaultAdditionalTaintStep

其中几个关键的文件

  • semmle.code.java.dataflow.internal.TaintTrackingUtil
  • semmle.code.java.dataflow.TaintTracking
  • codeql.dataflow.TaintTracking

TaintTracking::Global<QueryInjectionFlowConfig> 是自定义规则中使用模块去最终定义的,这时候就会按照下面的路径去套取默认的自定义传播污点;

你的 QueryInjectionFlowConfig (implements DataFlow::ConfigSig)
            ↓
TaintTracking::Global<QueryInjectionFlowConfig>
            ↓
AddTaintDefaults<Config> (添加默认污点传播规则)
            ↓
defaultAdditionalTaintStep() (定义在 TaintTrackingUtil.qll)

看下自定义规则中的路径

在通用TaintTracking中的路径(非java-all)

可以看到其中只是个定义,没有实现

这里则是java-all中的TaintTracking定义,可以看到 TaintFlowMake 和 JavaTaintTracking 将签名统一了起来,进而在TaintTrackingUtil实现了这个 defaultAdditionalTaintStep 定义

架构设计模式:签名 (Signature) 与实现 (Implementation) 分离

// 通用签名定义(在通用 TaintTracking.qll 中)
signature module InputSig<LocationSig Location, DF::InputSig<Location> Lang> {
  predicate defaultAdditionalTaintStep(Lang::Node src, Lang::Node sink, string model);
  // 这里只是签名,没有具体实现
}

这是 CodeQL 的模块签名机制,类似于接口(Interface)的概念。InputSig 只是定义了契约,要求实现该签名的模块必须提供 defaultAdditionalTaintStep 的具体实现。

1. TaintFlowMake<Location, JavaDataFlow, JavaTaintTracking>
                                         ^^^^^^^^^^^^^^^^
2. JavaTaintTracking (隐式) implements InputSig
3. JavaTaintTracking 使用 TaintTrackingUtil 中的 defaultAdditionalTaintStep
4. AddTaintDefaults 模块自动引入这些默认步骤

默认的传播逻辑

defaultAdditionalTaintStep的定义

predicate defaultAdditionalTaintStep(DataFlow::Node src, DataFlow::Node sink, string model) {
  localAdditionalTaintStep(src, sink, model)           // 本地额外污点步骤
  or
  entrypointFieldStep(src, sink) and model = "entrypointFieldStep"  // 入口点字段步骤
  or
  any(AdditionalTaintStep a).step(src, sink) and model = "AdditionalTaintStep"  // 用户自定义步骤
}

本地额外污点步骤 (localAdditionalTaintStep)

这个其实就是官方的传播规则定义,其余部分的定义其实关系就不大了。

/**
   * Holds if taint can flow in one local step from `src` to `sink` excluding
   * local data flow steps. That is, `src` and `sink` are likely to represent
   * different objects.
   */
  cached
  predicate localAdditionalTaintStep(DataFlow::Node src, DataFlow::Node sink, string model) {
    localAdditionalTaintExprStep(src.asExpr(), sink.asExpr(), model)
    or
    localAdditionalTaintUpdateStep(src.asExpr(),
      sink.(DataFlow::PostUpdateNode).getPreUpdateNode().asExpr(), model)
    or
    exists(DataFlow::Content f |
      readStep(src, f, sink) and
      model = "" and
      not sink.getTypeBound() instanceof PrimitiveType and
      not sink.getTypeBound() instanceof BoxedType and
      not sink.getTypeBound() instanceof NumberType and
      (
        containerContent(f)
        or
        f instanceof TaintInheritingContent
      )
    )
    or
    FlowSummaryImpl::Private::Steps::summaryLocalStep(src.(DataFlowPrivate::FlowSummaryNode)
          .getSummaryNode(), sink.(DataFlowPrivate::FlowSummaryNode).getSummaryNode(), false, model)
  }

表达式级别的污点传播 (localAdditionalTaintExprStep)

这个个人理解就是相关对象初始化、方法调用、常见的传播(字符串或者逻辑运算相关操作)。

/**
 * Holds if taint can flow in one local step from `src` to `sink` excluding
 * local data flow steps. That is, `src` and `sink` are likely to represent
 * different objects.
 */
private predicate localAdditionalTaintExprStep(Expr src, Expr sink, string model) {
  (
    sink.(AddExpr).getAnOperand() = src and sink.getType() instanceof TypeString
    or
    sink.(AssignAddExpr).getSource() = src and sink.getType() instanceof TypeString
    or
    sink.(StringTemplateExpr).getComponent(_) = src
    or
    sink.(LogicExpr).getAnOperand() = src
  ) and
  model = ""
  or
  constructorStep(src, sink, model)
  or
  qualifierToMethodStep(src, sink, model)
  or
  argToMethodStep(src, sink, model)
  or
  comparisonStep(src, sink) and model = ""
  or
  serializationStep(src, sink) and model = "serializationStep"
  or
  formatStep(src, sink) and model = "formatStep"
}

字符串操作

  • 字符串拼接 (AddExpr):"hello" + taintedVar
  • 赋值拼接 (AssignAddExpr):str += taintedVar
  • 字符串模板 (StringTemplateExpr):Java 字符串模板表达式
  • 逻辑表达式 (LogicExpr):&& 和 || 操作

方法调用传播(强调返回值)

  • 构造函数步骤 (constructorStep):
  • InputStream 包装器构造函数
  • 通过扩展构造的包装器
  • TaintPreservingCallable 构造函数
  • 限定符到方法调用 (qualifierToMethodStep):
  • StringWriter.getBuffer() / StringWriter.toString()
  • ObjectInputStream.read*() 方法
  • Spring 不受信任数据类型的 getter 方法
  • TaintPreservingCallable 返回污点。且 returnsTaintFrom(-1)(表示从 qualifier 返回污染)可以进行扩展
class MyCryptoCallable extends TaintPreservingCallable {
  MyCryptoCallable() {
    this.getDeclaringType().hasQualifiedName("com.example", "CryptoUtils") and
    this.hasName("encrypt")
  }

  // 必须 override,否则 qualifier 不会传播到返回值
  override predicate returnsTaintFrom(int arg) { arg = -1 }
}

具体含义说明:
String result = JSON.toJSONString(); 中,如果 JSON 被污染,则 result 也会被污染
  • JAX-RS 资源方法的 getter
  • 参数到方法调用 (argToMethodStep):
  • Base64 编码/解码:Base64.decodeBase64(), Base64.encodeBase64*()
  • Spring ResponseEntity:ResponseEntity.ok(), ResponseEntity.of()
  • Spring ResponseEntityBodyBuilder:body() 方法
  • TaintPreservingCallable 参数传播(自定义,可扩展,参数i必须≥0)
private class NumberTaintPreservingCallable extends TaintPreservingCallable {
  int argument;

  NumberTaintPreservingCallable() {
    this.getDeclaringType().getASourceSupertype*().hasQualifiedName("java.lang", "Number") and
    (
      this instanceof Constructor and
      argument = 0 //代表第一个参数
      or
      this.getName().matches(["to%String", "toByteArray", "%Value"]) and
      argument = -1//代表整个限定词整体
      or
      this.getName().matches(["parse%", "valueOf%", "to%String", "decode"]) and
      argument = 0
    )
  }

  override predicate returnsTaintFrom(int arg) { arg = argument }
}

具体含义说明:
String result = cryptoUtils.encrypt(taintedData); 中,如果 taintedData 被污染,则 result 也会被污染

特殊操作

  • 比较步骤 (comparisonStep):与常量的比较或相等测试
  • 序列化步骤 (serializationStep):通过 ObjectOutputStream 的数据序列化
  • 格式化步骤 (formatStep):通过 Formatter 的字符串格式化

可能看上面会感觉codeql的官方规则写的比较全,但是严格老说

更新级别的污点传播 (localAdditionalTaintUpdateStep)

private predicate localAdditionalTaintUpdateStep(Expr src, Expr sink, string model) {
  qualifierToArgumentStep(src, sink, model)
  or
  argToArgStep(src, sink, model)
  or
  argToQualifierStep(src, sink, model)
}
  • 限定符到参数 (qualifierToArgumentStep):obj.method(arg) 中从 obj 到 arg
  • 参数到参数 (argToArgStep):方法参数之间的污点传播
  • 参数到限定符 (argToQualifierStep):从方法参数到调用对象
**1、限定符到参数 (qualifierToArgumentStep)**
// 示例:污染的对象调用方法,污染传递给参数
TaintedObject obj = getTaintedObject();
String[] buffer = new String[10];
obj.fillBuffer(buffer);  // obj(qualifier) → buffer(argument)
// 现在 buffer 被污染

2、**参数到参数 (argToArgStep)**
// 示例:数据复制方法
String[] source = getTaintedArray();
String[] dest = new String[10];
ArrayUtils.copy(source, dest);  // source(arg0) → dest(arg1)
// 现在 dest 被污染

3、**参数到限定符 (argToQualifierStep)**
// 示例:对象状态设置
StringBuilder sb = new StringBuilder();
String taintedData = getTaintedString();
sb.append(taintedData);  // taintedData(argument) → sb(qualifier)
// 现在 sb 被污染

TaintPreservingCallable 实现自定义更新污点传播


predicate transfersTaint(int src, int sink) { none() } 当位置 src 的输入被污染时,污点会传递到位置 sink,通常涉及对象状态的修改而非返回值。

参数含义

  • src:污点源的位置索引
  • src >= 0:方法参数索引(0 = 第一个参数)
  • src = -1:调用对象(qualifier)
  • sink:污点目标的位置索引
  • sink >= 0:方法参数索引(会被修改)
  • sink = -1:调用对象(会被修改)

自定义transfersTaint

class MyCollectionCallable extends TaintPreservingCallable {
  MyCollectionCallable() {
    this.getDeclaringType().hasQualifiedName("com.example", "MyCollection") and
    this.hasName(["add", "addAll", "set"])
  }

  override predicate transfersTaint(int src, int sink) {
    // 参数污点传递给集合对象
    this.hasName(["add", "addAll"]) and src = 0 and sink = -1
    or
    // set 方法:第二个参数污点传递给集合对象
    this.hasName("set") and src = 1 and sink = -1
  }
}

使用效果:

MyCollection<String> collection = new MyCollection<>();
collection.add(taintedString);     // taintedString → collection
collection.set(0, taintedString);  // taintedString → collection

与 returnsTaintFrom的区别

方面

returnsTaintFrom

transfersTaint

传播目标

方法返回值

方法参数或调用对象

对象状态

创建新对象

修改现有对象

使用场景

result = obj.method(param)

obj.method(param) 修改 obj 或 param

数据流类型

值流

引用流/状态更新

📌

与 localAdditionalTaintExprStep 的区别

方面

localAdditionalTaintExprStep

localAdditionalTaintUpdateStep

对象创建

通常创建新对象

修改现有对象状态

返回值

污点传播到方法返回值

污点传播到参数或调用对象

数据流类型

值传播(新对象)

引用传播(对象更新)

典型场景

result = method(tainted)

obj.method(tainted) 修改 obj

2.3 容器内容传播

  • 数组内容:DataFlow::ArrayContent
  • 集合内容:DataFlow::CollectionContent
  • Map 值内容:DataFlow::MapValueContent or MapKeyContent
  • 继承污点的内容:TaintInheritingContent

2.4 流总结步骤

  • 库代码流总结:FlowSummaryImpl 定义的本地步骤

入口点字段步骤 (entrypointFieldStep)

  • 字段读取传播:从威胁模型源类型的对象到其字段的污点传播
  • 适用场景:当源是 ActiveThreatModelSource 参数类型的字段访问时

用户自定义步骤

  • 扩展机制:允许用户通过继承 AdditionalTaintStep TaintPreservingCallable类添加自定义污点传播规则
  • 灵活性:支持特定应用或框架的污点传播需求

当然需要说明下,其实AdditionalTaintStep应该算是官方自己的内部扩展机制,实现的话自身定义其实没有太大问题,用户级别自定义的扩展可以按照官方下面的两种思路延伸,当然其实也可以直接定义到 DataFlow::ConfigSig中的 isBarrier 或者 isAdditionalFlowStep 中,也是可以的;

AdditionalTaintStep 扩展

这个我看官方规则使用来给自己相关架构做扩展的,比如java spring这些;具体信息

semmle.code.java.dataflow.FlowSources 中:

private import java
private import semmle.code.java.dataflow.DataFlow

/**
 * A module importing the frameworks that implement additional flow steps,
 * ensuring that they are visible to the taint tracking library.
 */
private module Frameworks {
  private import semmle.code.java.frameworks.android.AsyncTask
  private import semmle.code.java.frameworks.android.Intent
  private import semmle.code.java.frameworks.android.Slice
  private import semmle.code.java.frameworks.android.SQLite
  private import semmle.code.java.frameworks.android.Widget
  private import semmle.code.java.frameworks.apache.Lang
  private import semmle.code.java.frameworks.ApacheHttp
  private import semmle.code.java.frameworks.guava.Guava
  private import semmle.code.java.frameworks.Guice
  private import semmle.code.java.frameworks.IoJsonWebToken
  private import semmle.code.java.frameworks.jackson.JacksonSerializability
  private import semmle.code.java.frameworks.InputStream
  private import semmle.code.java.frameworks.Networking
  private import semmle.code.java.frameworks.Properties
  private import semmle.code.java.frameworks.Protobuf
  private import semmle.code.java.frameworks.ThreadLocal
  private import semmle.code.java.frameworks.ratpack.RatpackExec
  private import semmle.code.java.frameworks.stapler.Stapler
  private import semmle.code.java.security.ListOfConstantsSanitizer
  private import semmle.code.java.security.PathSanitizer
}
....
class AdditionalTaintStep extends Unit {
  /**
   * Holds if the step from `node1` to `node2` should be considered a taint
   * step for all configurations.
   */
  abstract predicate step(DataFlow::Node node1, DataFlow::Node node2);
}

框架内部AdditionalTaintStep的定义

内部中关于java.io.InputStream的污点传播流扩展

从上面可以知道,用户自定义扩展也可以按照下面官方sql注入的类似思路,这个我理解和上面AdditionalTaintStep区别不大,安全的相关污点分析中我看很多都是使用这种方式来进行自定义;

自定义规则
module QueryInjectionFlowConfig implements DataFlow::ConfigSig {

  predicate isSource(DataFlow::Node src) { 
    src.asParameter() = any(SpringRequestMappingParameter srmp | srmp.isTaintedInput()) 
  }

  predicate isSink(DataFlow::Node sink) { sink instanceof QueryInjectionSink }

  predicate isBarrier(DataFlow::Node node) { 
      node.getType() instanceof SanitizeType
  }

  predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2) {
    any(AdditionalQueryInjectionTaintStep s).step(node1, node2)
  }

  predicate observeDiffInformedIncrementalMode() { any() }
  
  
semmle.code.java.security.QueryInjection 中的扩展实现
  
class AdditionalQueryInjectionTaintStep extends Unit {
  /**
   * Holds if the step from `node1` to `node2` should be considered a taint
   * step for SQL injection taint configurations.
   */
  abstract predicate step(DataFlow::Node node1, DataFlow::Node node2);
}
  
  private class MongoJsonStep extends AdditionalQueryInjectionTaintStep {
  override predicate step(DataFlow::Node node1, DataFlow::Node node2) {
    exists(MethodCall ma |
      ma.getMethod().getDeclaringType().hasQualifiedName("com.mongodb.util", "JSON") and
      ma.getMethod().hasName("parse") and
      ma.getArgument(0) = node1.asExpr() and
      ma = node2.asExpr()
    )
  }
}

TaintPreservingCallable 扩展

上面可能是官方推荐的自定义方式,下面这是个人理解采用之前一直提到的在localAdditionalTaintStep.TaintPreservingCallable中的自定义污点传播逻辑。这个优点在于更为通用,个人感觉会更方便一些。常见的传播流自定义到一起,直接一个import导入即可;

TaintPreservingCallable 的扩展更灵活一点,因为有时候污点流基本都是常见流程,可以自己定义一个污点流文件propagate.qll,创建自定义查询规则的时候直接 import propagate引入即可,因为前文可以知道,根据ql的继承机制采用默认的 TaintTracking::Global 是默认继承这些实现的;

不过我想最为关键的这里应该是可以直接引用官方的相关规则库,避免过多冗余业务逻辑实现;看上面的各种 private import semmle.code.java.frameworks.Networking 这种可以去看下都有哪些实现。说不定已经实现好了;

TaintPreservingCallable的测试

前文介绍localAdditionalTaintStep的时候,如果有感触就会发现,真实的业务上参数到限定符(argToQualifierStep)、参数到方法调用 (argToMethodStep)、限定符到方法调用 (qualifierToMethodStep)这几个是最常见的场景,几乎覆盖了所有常见的情况;,这里就做下相关的测试;

这里扩展TaintPreservingCallable 的参数到返回值

这是检测规则,也可以切换成module TaintFlow = DataFlow::Global<TestConfig>;普通数据流,只有5场景;

这是AI生成测试代码,正常只会检测出来1、3、4、5;添加扩展后可以检测出来2(这个String.valueOf在下面介绍)

其实这里可以看出,虽然官方的codeql虽然设计的同完善,但是很多基础的传播流并没有补充很完善,真正看过codeql上面的具体谓词实现你也会发现其实很多都是空的,大部分实现的话也就一两个而已

6其实算是误报场景

检测结果

// === 测试场景5: qualifierToArgumentStep (Qualifier → 参数) ===
        List<String> taintedList = Arrays.asList(tainted);
        String[] array = new String[10];
        taintedList.toArray(array);  // taintedList(qualifier) → array(参数)
        sink("qualifierToArgumentStep", array[0]);

库规则自定义

这时候就有人问了,还有没有更简单的方法定义污点流?

有的兄弟,有的。

https://codeql.github.com/docs/codeql-language-guides/customizing-library-models-for-java-and-kotlin/

结合上面对自定义规则不完善的思考,猜测可能这个库模型定义才是官方未来主要推进的实现定义的方式,这个也确实定义起来更简单方便。这个我记得tai-e的检测大概也是使用类似方式扩展的。

SSRF的测试

这里找个https://github.com/l4yn3/micro_service_seclab这个ssrf漏洞做测试,官方规则中对于下面这个有两个地方是没法检测的,下面three这个关键点在于 com.squareup.okhttp.Request.Builder 相关的传播链路是没有的,但是okhttp3的相关流处理是有的。

squareup.okhttp

@RequestMapping(value = "/three")
    public String Three(@RequestParam(value = "url") String imageUrl) {
        try {
            URL url = new URL(imageUrl);
            OkHttpClient client = new OkHttpClient();
            com.squareup.okhttp.Request request = new com.squareup.okhttp.Request.Builder().get().url(url).build();
            Call call = client.newCall(request);
            Response response = call.execute();
            return response.toString();
        } catch (IOException var1) {
            System.out.println(var1);
            return "Hello";
        }
    }

这里拿okhttp3的已经有的规则给替换到com.squareup.okhttp上。但是kind需要是 taint 才能在污点漏洞分析中进行正确使用,如果是value则是没有效果的。

ext/com.squareup.okhttp.model.yml

extensions:
  - addsTo:
      pack: codeql/java-all
      extensible: sinkModel
    data:
      - ["com.squareup.okhttp", "OkHttpClient", True, "newCall", "(Request)", "", "Argument[0]", "request-forgery", "ai-manual"]
      - ["com.squareup.okhttp", "OkHttpClient", True, "newWebSocket", "(Request,WebSocketListener)", "", "Argument[0]", "request-forgery", "ai-manual"]
      # - ["com.squareup.okhttp", "Request", True, "Request", "", "", "Argument[0]", "request-forgery", "manual"]
      # - ["com.squareup.okhttp", "Request$Builder", True, "url", "", "", "Argument[0]", "request-forgery", "manual"]
  - addsTo:
      pack: codeql/java-all
      extensible: summaryModel
    data:     
      - ["com.squareup.okhttp", "Request$Builder", True, "url", "", "", "Argument[0]", "ReturnValue", "taint", "ai-manual"]
      - ["com.squareup.okhttp", "Request$Builder", True, "build", "()", "", "Argument[this]", "ReturnValue", "taint", "ai-manual"]

至于怎么引用进来的,需要在对应规则的qlpack.yml中添加

dataExtensions:
  - ext/*.model.yml

String.valueOf(url) 的传播

官方所有关于SSRF的规则处理在 semmle.code.java.security.RequestForgery 中

进行SSRF的测试中发现会有相关sink点的内容是具备并且完善的,类似上面其实就是污点传播导致的问题;类似上面的也可以看出okhttp3的相关规则是很完善的。

上面可以看出okhttp3相关sink点,是具备OkHttpClient.newCall的

官方规则只检测了1、4、5;

关于2其实是里面的String.valueOf(url)这里的问题。但是这次就不用库模型的规则定义测试了,这次使用TaintPreservingCallable的方式进行实现:

import java
import semmle.code.java.dataflow.FlowSources


private class CustomDataProcessorCallable extends TaintPreservingCallable {
  CustomDataProcessorCallable() {
     this.getDeclaringType().hasQualifiedName("java.lang", "String")
  }

  override predicate returnsTaintFrom(int arg) {
    this.hasName("valueOf") and arg = 0
  }
}

//java.lang.String#valueOf(java.lang.Object)

进行相关检测的时候如果上面的文件命名propagate,并且在同一目录,则直接import propagate即可,这时候由于TaintTracking::Global<BaseFlowConfig>的作用,这个自定义的传播就会自动生效;

import propagate
import semmle.code.java.dataflow.FlowSources
private import semmle.code.java.dataflow.TaintTracking
import BaseInjectionFlow::PathGraph


module BaseFlowConfig implements DataFlow::ConfigSig {
  predicate isSource(DataFlow::Node source) { source instanceof ActiveThreatModelSource }

  predicate isSink(DataFlow::Node sink) { sink instanceof CeshiServiceSink }

  predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2) {
    none()
  }

  predicate observeDiffInformedIncrementalMode() { any() }
}


module BaseInjectionFlow = TaintTracking::Global<BaseFlowConfig>;



from BaseInjectionFlow::PathNode source, BaseInjectionFlow::PathNode sink
where BaseInjectionFlow::flowPath(source, sink)
select sink.getNode(), source, sink, "JNDI lookup might include name from $@.", source.getNode(),
  "this user input"

总结

整体上来看codeql官方设计了一套可扩展污点传播的检测规则,对于各个方面考虑比较完善,但是实际情况如上面讲到的实际案例来看官方的检测规则还有很多一部分需要去补充完善。还有个问题就是在source点的规则会发现官方的想法可能是更加考虑漏报率,但是当前检测规则的不完善又导致了误报的产生。这个可能也是官方希望规则更细粒化的原因。其实也可以通过类似上面的手动补充来完善这个矛盾。不过这里对于做甲方的应用安全能力建设上来看要想做的一个平衡漏报和误报的SAST还是需要人工的运营支持的。