Intro

Tai-e作为一个优秀的静态分析框架,内置了指针分析、污点分析等等实现。为增强其作为一个底座框架的可扩展性,其提供了插件系统,通过插件系统可以控制在静态分析过程中的各个阶段的数据处理,更进一步的进行定制化分析的实现。如下图为Tai-e官方提供的有关于插件系统的原理图:

本文中提及的有关于微服务应用的静态分析框架MScan同样是基于Tai-e进行实现的,针对微服务应用中使用的一些特殊的API进行服务间的高速通信过程,传统的静态分析方式不能够原生支持该类服务间通信的污点流的传播,但是这里采用了上面介绍了插件系统的方式,为服务间的通信过程进行建模,定制化的支持该过程的数据流分析,例如是Grpc、Dubbo或者Feign等通信方式。

具体的分析因篇幅太长分为了上下两篇,上篇主要集中于理论层面的代码分析,剖析基于Tai-e框架的改造细节,明晰从source点提取到扩展的污点分析引擎工作原理的全流程。而下篇主要集中于实战层面的内容,在剖析微服务应用各服务间的通信建模方式,也即如何构建一个SDG(Service Dependence Graph),同时贴近实战批量拉取github\gitee高star项目进行自动化 clone-complie-scan全流程。

DistancePruning

该类的实现对应着论文中提及到的基于距离引导的上下文选择策略,但是感觉具体对其的实现还是和论文中的描述存在出入,后面具体分析其实现

在options.yml中若对advance进行配置,将会使用特定的上下文选择器,这里的动态上下文选择策略的实现和核心逻辑在DistancePruning#run,核心是三个原则

  1. 对于一个方法,其能够调用到某一个sink点方法且能够被某一个source点方法调用到(不局限于单次调用,只要在调用图上能找到一个调用链即可),对于这样的方法,将其csMap的值设为MAX,也即是这样的方法采用最大的上下文进行分析
  2. 对于仅仅能够形成调用链到sink点方法,但不能够某个source点方法调用的方法,这样的方法,将其csMap的值设为固定的2,在分析时采用2-call的方法进行上下文的选择
  3. 而对于上述两种情况都不满足的情况,则直接将其上下文选择为MIN,采用最小的上下文

总的来说,虽然与论文中提出的基于一个方法到达最近的source-sink链的距离进行上下文的选择有所出路,但是这里的上下文选择方法也是基于一个context-insensitivity的分析结果,所以对于可能的source-to-sink调用链长度进行最大上下文的选择也一种有效的避免假阳性的方法

与此同时,注意到在Pruning类也存在有两种上下文选择的思路

  1. csMapByTaintNum方法,基于一种成本控制的思路进行上下文的选择,首先通过流式处理,从指针分析结果(pta)的调用图中获取所有可到达的方法(reachableMethods),对于每个方法,计算其参数中属于“污点”(Taint)的数量。然后过滤掉污点参数数为0的方法,并将剩余方法按污点参数数从高到低排序。确保了那些更可能涉及敏感数据流的方法会被优先考虑

总的来说,上下文的大小是由一个动态的分析成本预算控制的。它优先处理污点参数多的方法,但同时严格限制方法的分析成本总和不超过上限(硬件条件)。这种设计巧妙地在分析广度(覆盖更多方法)和深度(分析复杂方法)之间取得了平衡,防止资源消耗无限增长

  • 对于每个方法,只有当累计成本 count小于阈值(1e5)时,才会将其加入 csMap并标记为 "5",同时计数器 count5增1
  • 如果方法非抽象,则计算其分析成本:变量数 * (调用者数量)^4,并将此成本累加到 count上
  • 一旦 count的值达到或超过 1e5,循环便会停止,后续方法不再被加入 csMap
  1. csMapByTaintFlow方法,这个方法猜测是想基于通过上下文不敏感的静态分析结果得到的TaintFlow进行上下文的动态选择,但是感觉后面可能烂尾了,没有实现完

SDG (Service Dependence Graph)

OpenFeignPlugin

该插件核心是用来建立通过Feign方式进行跨服务调用的调用边,用于构建SDG (Service Dependence Graph)

对于该插件同样是实现了标准的Plugin接口,其实现了onStart方法以及onNewCSMethod方法用于在程序分析前进行处理以及在遭遇新的方法时进行处理

对于onstart主要是在静态分析前对FeignClient进行处理,获取所有的feign类型的路由以及实现类,保存在mappingEdges中

而对于onNewCSMethod实现了一个访问者模式,遍历遇到的所有新方法的所有Stmt,如何遇到函数调用的Stmt则会考虑其是否是一个invokeInterface类型的调用,也即是是否调用的是实现的接口的方法,这里是用来处理Feign这种方式进行跨服务通信的机制,根据feignClient类的类签名从mappingEdges获取所有的实现方法,并通过addCallEdge为这个调用过程建立一个调用边

GrpcPlugin

这个插件所起的作用和OpenFeignPlugin类似,均是用来处理微服务中的各个service间的调用关系

前者是用来处理Feign这种调用方式,这里的插件是用来处理通过Grpc这种方式进行调用的方式

对于onStart方法,其主要是用于构建invoke-callee的映射,也即是调用关系,Grpc服务端以及客户端stub的实现分别是实现了io.grpc.BindableService或者io.grpc.stub.AbstractStub

  1. 通过获取所有自己实现的io.grpc.BindableService类,将其有参类方法存储在serviceMethod,作为对位提供的grpc方法
  2. 筛选所有Grpc客户端的实现方法,通过审查所有的invoke函数调用,若被调用的函数所在类属于io.grpc.stub.AbstractStub实现,则认为其是一个客户端stub,获取这个远程调用方法的第一个参数变量,构建了一个var-invoke的映射,同时如果该方法能够在grpc服务端实现的可调用方法中找到的话,会构建一个从客户端调用点到被具体调用的方法的一个映射invoke2calleeMap

而onNewCSMethod同样是在基于访问者模式构建一个跨服务调用的关系

  1. 对于所有跨服务调用点,在PFG (Pointer Flow Graph)上构建一个被调用方法参数传递的边,同时构建一个调用边
  2. 处理在微服务中采用guice这种轻量级的依赖注入组件,通过寻找其实现类的方式直接通过addPointsTo建立联系

RestTemplatePlugin

该插件用来处理使用RestTemplate进行各服务间通信的调用关系

  1. 最开始通过筛选exchange函数的调用点,构建var2InvokeMap用来映射exchange的传参以及调用点
  2. 在指针集发生变化时,通过var2InvokeMap中var所对应的指针集去获取想要请求的URI是什么,并保存在targetString中
  3. 遍历上面收集的targetString,与GatewaySourcePlugin插件中识别到的endpoint的路由做比对,如果存在匹配成功的情况,将会构建一个从exchange函数调用点到对应路由提供者方法的一个调用边,并通过addPFGEdge将传入的参数进行跨服务传递

DubboPlugin

dubbo作为一个RPC服务开发框架,同样提供一种在微服务架构中进行不同服务通信的方式,这里的DubboPlugin也即是对其进行支持,构建dubbo场景下的服务依赖图

在静态分析前基于注解进行dubbo服务端的识别

在指针分析过程中实时筛选所有的函数调用过程,如果存在调用了dubbo服务的函数,则建立此调用点到dobbo服务中定义的目标函数的调用边

KafkaPlugin

该插件用来处理在微服务框架中采用kafka进行服务间通信的方式

首先在进行静态分析之前,onStart方法中,从ApplicationClass中获取被KafkaListener注解的消费者方法,并以topic-method的映射保存在kafkaListeners中。同时从获取到生产者方法保存在kafkaSendMethods中

其次是在onNewStmt事件触发时,判断是否是调用的生产者方法,若是的话,构建生产者方法的第一个参数,也就是topic和方法调用的一个映射

最后则是在指针集发生变化是触发的onNewPointsToSet事件中,判断是否topic对应的指向出现变化,遍历获取其指代的所有topic后在kafkaListeners寻找是否存在有消费该topic的消费者方法,若存在,将会通过addPFGEdge构建一个从生产者方法生产的消息内容到消费者方法消费的消息内容的指向边,以及通过addCallEdge构建一个从生产者方法到消费者方法的调用边

RabbitMQPlugin

该插件和kafka处理的对象都是消息队列的跨服务通信的依赖构建,且都是采用消息队列的方式,实现逻辑也类似

  1. 将消费者的监听队列以及处理时间方法映射保存在rabbitmqListeners中,以及将生产者的消息发送方法保存在rabbitmqSendMethods中
  2. 构建消息发送函数调用同exchange和route key的映射关系,同时构建消息处理函数调用同queue, exchange, route key的映射关系
  3. 类似的,最后就是根据route key以及exchange去匹配对应的消费者方法,同时构建从发送者方法所发送消息到消费者方法所消费消息的pointer edge,以及构建在消息发送点到消息处理点的call edge


Full progress

对于tai-e的整个流程大致可以分为以下的过程

  1. 进行静态分析前的准备工作,包括有指定appClassPath以及ClassPath

而对于这里的Mscan,包括有以下几点:

  • 将配置文件中的Config.classpathKeywords添加到classpathKeywords中
  • 将前面Jar parser中提取到到的${targetPath}/BOOT-INF/classes中的类添加到appClassPath中
  • 将Jar parser提取到的${targetPath}/BOOT-INF/lib中的jar包添加到classPath中

  1. 通过options中的配置去生成对应的plan文件
  2. 调用Soot对所有的类进行解析,包括有BOOT-INF/classes以及BOOT-INF/lib中的类,核心是使用了SootWorldBuilder#build方法进行处理
  3. 执行前面生成的analysis plan,对于pta,则使用对应的配置调用PointerAnalysis#analyze进行分析
  1. 首先是构建一个Heap abstraction,用来将动态时无限的对象抽象为有限,通常选用为Allocation-Site这一抽象方式
  2. 其次则是构建ContextSelector,优先使用advanced中的配置,若没有配置advanced,则根据makePlainSelector去正常获取上下文选择器,支持有以下context selector variant

  • ci: context-insensitive analysis
  • k-obj/call/type
  1. 在构建了heap abstraction以及context selector后调用runAnalysis进入指针分析逻辑
  2. 在核心的指针分析逻辑中,其主要是根据heapModel以及selector构建一个Solver对象,通过其中的solve方法进行分析

值得注意的是,tai-e设计中存在有一个扩展性极强的插件系统,详情可见https://tai-e.pascal-lab.net/docs/current/reference/en/index-single.html#analysis-plugin-system

  1. 对于solve方法,其实现了指针分析算法
  2. 其中算法的伪代码中的添加入口点以及addReachable由DafaultSolver#initialize方法实现,其首先对一些全局变量进行了初始化,核心是通过插件系统的onStart方法调用去实现,依靠插件系统可以实现在整个程序分析的生命周期中的各个环节的实时计算,这里通过onStart方法调用,一方面对装载的各个插件进行初始化,另一方面对算法中的addEntry以及addReachable进行实现
  3. 而对于solve方法的第二部分,也即是analyze则对应于伪代码中的work list的处理过程,核心是对于work list中的各个元素,首先判断其指针集是否存在变化,若存在变化则处理对应的store以及load操作
  1. 对于指针分析的分析结果其通过构建一个PointerAnalysisResultImpl对象,存储了调用图,指针流图,指针集等丰富的信息,且最终的分析结果根据analysis-id的对应关系保存在了World中

Real world

上述内容主要是对静态分析框架的整个框架的原理以及代码实现进行了阐述,下面基于上面的静态分析框架为基座,构建了一个clone-complie-scan全流程的自动化漏洞检测闭环

clone

首先是clone环节,对于目标项目的选择,我们采用github以及gitee平台提供的筛选的功能对高star的Java项目进行初步筛选,后续得益于LLM的理解能力,通过LLM对初筛的项目文档进行理解对项目进行分类,具体可以从两个角度进行分类

  1. 使用maven进行项目编译还是gradle进行项目编译:通过识别项目的编译方式以便于下一步的自动化编译过程
  2. 项目所具备的特征:例如是一个微服务项目或者电商项目,通过这样的方法对业务进行分类

同时,在收集的过程中,也不单单局限于仅对微服务相关项目进行收集,可对全部的基于Java开发的项目进行收集进行批量检测

如上图所示,则是收集的一些Java项目的样例,通过yml文件的方式将待检测项目进行归类

之后分别提取每一个项目的URL,通过调用系统命令 git clone的方法将项目克隆到本地

async def clone_all_projects(self, max_concurrent: int = 5):
    """异步克隆所有项目"""
    logger.info("开始克隆项目阶段...")
    
    # if self.progress.get('stage') == 'clone' and self.progress.get('cloned_projects'):
    if self.progress.get('stage') == 'clone' and self.progress.get('cloned_projects'):
        logger.info(f"检测到已有进度,已克隆 {len(self.progress['cloned_projects'])} 个项目")
        # 过滤已克隆的项目
        cloned_urls = {p['url'] for p in self.progress['cloned_projects']}
        remaining_projects = [p for p in self.projects_info if p['url'] not in cloned_urls]
    else:
        remaining_projects = self.projects_info
    
    logger.info(f"待克隆项目数量: {len(remaining_projects)}")
    self.progress['failed_clone_urls'] = []
    
    semaphore = asyncio.Semaphore(max_concurrent)
    
    async def clone_with_semaphore(project_info):
        async with semaphore:
            return await self.clone_project(project_info)
    
    tasks = [clone_with_semaphore(project) for project in remaining_projects]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    
    # 处理结果
    for result in results:
        if isinstance(result, Exception):
            logger.error(f"克隆过程中出现异常: {result}")
            continue
        
        success, identifier = result
        if not success:
            self.progress['failed_clone_urls'].append(identifier)
            self.save_progress_immediate()  # 立即保存失败信息
    
    # 保存失败的URL到文件
    if self.progress['failed_clone_urls']:
        with open(FAIL_CLONE_URLS_FILE, 'w', encoding='utf-8') as f:
            for url in self.progress['failed_clone_urls']:
                f.write(f"{url}\n")
        logger.info(f"保存 {len(self.progress['failed_clone_urls'])} 个克隆失败的项目URL")
    
    # 更新进度
    self.progress['stage'] = 'build'
    self._save_progress()
    
    logger.info(f"克隆阶段完成,成功: {len(self.progress['cloned_projects'])}, 失败: {len(self.progress['failed_clone_urls'])}")

compile

而对于编译阶段,核心是对上一阶段克隆的项目进行编译处理,能够将项目打包成一个一个完成的jar包,以便于收集这些项目包使用静态分析工具进行漏洞检测任务。

通过前面项目收集过程中标注的该项目所采用的项目是基于Maven还是Gradle进行开发的,我们选择不同的系统命令进行Java项目的编译

def build_project(self, project_info: Dict) -> Tuple[bool, str]:
    """构建单个项目"""
    url = project_info['url']
    
    # 首先检查是否已经构建过这个项目
    built_urls = {p['url'] for p in self.progress.get('built_projects', [])}
    if url in built_urls:
        logger.info(f"跳过已构建的项目: {project_info['project_name']}")
        return True, url
    
    project_path = os.path.join(JAVA_WEB_PROJECTS_DIR, project_info['project_name'])
    
    # 获取构建目录(考虑cd字段)
    cd_path = project_info.get('cd', '')
    build_dir = self.get_build_directory(project_path, cd_path)
    
    # 检测构建类型
    build_type = self.detect_build_type(build_dir)
    
    try:
        os.chdir(build_dir)
        
        if build_type == 'maven':
            cmd = ["mvn", "clean", "package", "-DskipTests"]
        elif build_type == 'gradle':
            cmd = ["./gradlew", "build"] if os.path.exists("./gradlew") else ["gradle", "build"]
        else:
            logger.warning(f"未知的构建类型: {project_info['project_name']}, 构建目录: {build_dir}")
            return False, project_info['url']
        
        cd_info = f" (cd: {cd_path})" if cd_path else ""
        logger.info(f"开始构建: {project_info['project_name']}{cd_info} (使用 {build_type})")
        logger.info(f"构建目录: {build_dir}")
        
        result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
        
        if result.returncode == 0:
            logger.info(f"构建成功: {project_info['project_name']}")
            # 保存构建信息时包含cd路径
            project_info_with_cd = project_info.copy()
            project_info_with_cd['build_dir'] = build_dir
            project_info_with_cd['cd_path'] = cd_path
            self.progress['built_projects'].append(project_info_with_cd)
            self.save_progress_immediate()  # 立即保存进度
            return True, project_info['url']
        else:
            logger.error(f"构建失败: {project_info['project_name']}, 错误: {result.stderr[:500]}")
            return False, project_info['url']
            
    except subprocess.TimeoutExpired:
        logger.error(f"构建超时: {project_info['project_name']}")
        return False, project_info['url']
    except Exception as e:
        logger.error(f"构建异常: {project_info['project_name']}, 错误: {e}")
        return False, project_info['url']
    finally:
        # 恢复工作目录
        os.chdir("/home/roboterh/Codes/Myself/Research/code_audit_auto")

async def build_all_projects(self, max_concurrent: int = 5):
    """异步构建所有项目"""
    logger.info("开始构建项目阶段...")
    
    # 获取已克隆的项目
    cloned_projects = self.progress.get('cloned_projects', [])
    
    if self.progress.get('stage') == 'build' and self.progress.get('built_projects'):
        logger.info(f"检测到已有进度,已构建 {len(self.progress['built_projects'])} 个项目")
        # 过滤已构建的项目
        built_urls = {p['url'] for p in self.progress['built_projects']}
        remaining_projects = [p for p in cloned_projects if p['url'] not in built_urls]
    else:
        remaining_projects = cloned_projects
    
    # 记录有多少项目包含cd路径
    cd_projects = [p for p in remaining_projects if p.get('cd')]
    if cd_projects:
        logger.info(f"包含cd路径的项目数量: {len(cd_projects)}")
    
    logger.info(f"待构建项目数量: {len(remaining_projects)}")
    
    semaphore = asyncio.Semaphore(max_concurrent)
    
    async def build_with_semaphore(project_info):
        async with semaphore:
            loop = asyncio.get_event_loop()
            return await loop.run_in_executor(None, self.build_project, project_info)
    
    tasks = [build_with_semaphore(project) for project in remaining_projects]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    
    # 处理结果
    for result in results:
        if isinstance(result, Exception):
            logger.error(f"构建过程中出现异常: {result}")
            continue
        
        success, url = result
        if not success:
            self.progress['failed_build_urls'].append(url)
            self.save_progress_immediate()  # 立即保存失败信息
    
    # 保存失败的URL到文件
    if self.progress['failed_build_urls']:
        with open(FAIL_BUILD_URLS_FILE, 'w', encoding='utf-8') as f:
            for url in self.progress['failed_build_urls']:
                f.write(f"{url}\n")
        logger.info(f"保存 {len(self.progress['failed_build_urls'])} 个构建失败的项目URL")
    
    # 更新进度
    self.progress['stage'] = 'collect'
    self._save_progress()
    
    logger.info(f"构建阶段完成,成功: {len(self.progress['built_projects'])}, 失败: {len(self.progress['failed_build_urls'])}")

经过我的全过程的测试,值得注意的是,在进行项目编译的过程中不仅仅需要动态的选择不同的编译命令进行Java项目的编译,在编译过程中其核心会使用 JAVA_HOME这一环境变量所指向的JDK版本环境参与项目的编译过程,千人千面,不同的Java项目所能够支持的最低JDK版本不同,这里需要进行尝试性编译,也即是动态的调整JDK版本,按照从高到低的JDK版本对项目进行自动化编译,能够明显的降低仅采用同一种JDK版本进行编译而导致的编译失败几率。

在编译成功后会在对应目录中生成打包的Jar包,Maven项目默认的编译目录为 target,而Gradle项目默认的编译目录为 build

scan

上一阶段仅仅是对克隆的项目进行了编译、打包Jar任务,对于多模块开发的Java项目,其生成的Jar包散落在各个文件夹下的 target目录中,以便于静态工具进行扫描,我们首先需要将编译成功的Jars包进行收集整理到一起

def find_jar_files(self, root_dir):
    """
    收集指定根目录下的 jar 文件:
    - target 目录:仅收集第一层(直接子文件)的 jar 包(不遍历子目录)
    - build 目录:仅收集 build/libs 子目录下的 jar 包(libs 下的子目录可选是否遍历)
    排除文件名含 -sources/-test/-original 的文件
    :param root_dir: 项目根目录(遍历的起始目录)
    :param walk_build_libs_subdirs: 是否遍历 build/libs 下的子目录(默认 False,仅第一层)
    :return: 符合条件的 jar 文件完整路径列表
    """
    exclude_keywords = ['-sources', '-test', '-original', '-javadoc']
    filtered_jars = []
    walk_build_libs_subdirs = False  # 设为 True 则遍历 build/libs 下的子目录

    # 第一步:遍历所有目录,找到 target 和 build/libs 目录
    for current_root, dirs, files in os.walk(root_dir):
        # ------------------- 规则1:处理 target 目录(仅第一层文件) -------------------
        if os.path.basename(current_root) == 'target':  # 精准匹配当前目录是 target(而非路径含 target)
            # 仅处理 target 目录的直接子文件,不遍历子目录
            for file in files:
                if file.endswith('.jar') and all(kw not in file for kw in exclude_keywords):
                    full_path = os.path.join(current_root, file)
                    filtered_jars.append(full_path)
            # 跳过 target 目录的所有子目录(避免递归)
            dirs[:] = []  

        # ------------------- 规则2:处理 build/libs 目录 -------------------
        # 精准匹配当前目录是 build 下的 libs 子目录
        parent_dir = os.path.basename(os.path.dirname(current_root))  # 获取当前目录的父目录名
        current_dir = os.path.basename(current_root)
        if parent_dir == 'build' and current_dir == 'libs':
            # 处理 build/libs 目录下的文件
            for file in files:
                if file.endswith('.jar') and all(kw not in file for kw in exclude_keywords):
                    full_path = os.path.join(current_root, file)
                    filtered_jars.append(full_path)
            # 若不需要遍历 build/libs 下的子目录,清空 dirs 跳过
            if not walk_build_libs_subdirs:
                dirs[:] = []

    # 去重(避免不同目录下同名文件重复)
    filtered_jars = list(set(filtered_jars))
    return filtered_jars

def collect_jar_files(self, project_info: Dict) -> Tuple[bool, str]:
    """收集单个项目的jar文件"""
    url = project_info['url']
    
    # # 首先检查是否已经收集过这个项目的jar文件
    # collected_urls = {p['url'] for p in self.progress.get('collected_projects', [])}
    # if url in collected_urls:
    #     logger.info(f"跳过已收集jar文件的项目: {project_info['project_name']}")
    #     return True, url
    
    # 检查目标目录是否已存在jar文件(可能是之前手动收集的)
    project_name = project_info['project_name']
    target_dir = os.path.join(JARS_OF_JAVA_WEB_PROJECTS_DIR, project_name)
    if os.path.exists(target_dir):
        existing_jars = [f for f in os.listdir(target_dir) if f.endswith('.jar')]
        if existing_jars:
            logger.info(f"目标目录已存在 {len(existing_jars)} 个jar文件,跳过收集: {project_name}")
            project_info_with_cd = project_info.copy()
            project_info_with_cd['cd_path'] = project_info.get('cd_path', project_info.get('cd', ''))
            self.progress['collected_projects'].append(project_info_with_cd)
            return True, url
    
    source_path = os.path.join(JAVA_WEB_PROJECTS_DIR, project_name)
    
    try:
        # 确定搜索的源目录(考虑cd路径)
        cd_path = project_info.get('cd_path', project_info.get('cd', ''))
        if cd_path:
            search_path = os.path.join(source_path, cd_path)
            if not os.path.exists(search_path):
                search_path = source_path
                logger.warning(f"指定的cd路径不存在,使用项目根目录: {project_name}")
        else:
            search_path = source_path
        
        # 查找所有jar文件
        jar_files = self.find_jar_files(search_path)
        
        # 如果在指定目录下没有找到jar文件,尝试在整个项目目录中搜索
        if not jar_files and cd_path:
            jar_files = self.find_jar_files(source_path)
            logger.info(f"在指定目录未找到jar文件,扩展到整个项目搜索: {project_name}")
        
        if not jar_files:
            logger.warning(f"未找到jar文件: {project_name}, 搜索路径: {search_path}")
            return False, project_info['url']
        
        # 只有在找到有效jar文件时才创建目标目录
        os.makedirs(target_dir, exist_ok=True)
        
        # 复制jar文件
        copied_count = 0
        for jar_file in jar_files:
            try:
                jar_name = os.path.basename(jar_file)
                target_path = os.path.join(target_dir, jar_name)
                
                # 如果目标文件已存在,添加序号
                counter = 1
                final_target = target_path
                # while os.path.exists(final_target):
                #     logger.error(f"目标文件:{final_target},已存在")
                #     name, ext = os.path.splitext(jar_name)
                #     final_target = os.path.join(target_dir, f"{name}_{counter}{ext}")
                #     counter += 1
                if os.path.exists(final_target):
                    logger.error(f"目标文件:{final_target},已存在")
                    continue
                
                shutil.copy2(jar_file, final_target)
                copied_count += 1
            except Exception as e:
                logger.error(f"复制jar文件失败: {jar_file} -> {final_target}, 错误: {e}")
        
        cd_info = f" (cd: {cd_path})" if cd_path else ""
        logger.info(f"成功收集jar文件: {project_name}{cd_info}, 数量: {copied_count}")
        
        # 保存收集信息时包含cd路径
        project_info_with_cd = project_info.copy()
        project_info_with_cd['cd_path'] = cd_path
        self.progress['collected_projects'].append(project_info_with_cd)
        self.save_progress_immediate()  # 立即保存进度
        return True, project_info['url']

通过上述代码可以根据规则提取生成的jar包

而对于核心的扫描任务,我们首先对Mscan进行改造,使得将其打包后可以动态的修改options.yml文件以便于指定待检测项目以及检测过程中产生文件的保存位置

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
批量运行Tai-e分析脚本
1. 从progress.json读取collected_projects中的项目
2. 自动检测项目的classpath
3. 动态修改options.yml的outputDir
4. 执行Tai-e分析命令
"""

import os
import json
import yaml
import subprocess
import sys
import time
from pathlib import Path
from typing import List, Tuple, Dict

# 配置常量
PROGRESS_FILE = "/home/x/Codes/Myself/Research/code_audit_auto/progress.json"
JAVA_WEB_PROJECTS_DIR = "/home/x/Codes/Myself/Research/code_audit_auto/JavaWebProjects"
JARS_OF_JAVA_WEB_PROJECTS_DIR = "/home/x/Codes/Myself/Research/code_audit_auto/JarsOfJavaWebProjects"
OPTIONS_FILE = "/home/x/Codes/Myself/Research/code_audit_auto/options.yml"
JAVA_COMMAND = "/home/x/Envs/jdks/openlogic-openjdk-17.0.6+10-linux-x64/bin/java"
TAI_E_JAR = "tai-e-all-mcms-0.5.1-SNAPSHOT.jar"
TIMEOUT_SECONDS = 7200  # 1小时超时

class TaiEAnalysisBatch:
    def __init__(self):
        self.collected_projects = []
        self.original_options = None
        
        # 确保必要目录存在
        self._ensure_directories()
        
        # 加载进度和配置
        self._load_progress()
        self._load_options()
    
    def _ensure_directories(self):
        """确保必要目录存在"""
        for directory in ["outputs", "tmp", "outputs_auto"]:
            Path(directory).mkdir(parents=True, exist_ok=True)
    
    def _load_progress(self):
        """加载progress.json文件"""
        if not os.path.exists(PROGRESS_FILE):
            print(f"错误: {PROGRESS_FILE} 文件不存在")
            sys.exit(1)
        
        try:
            with open(PROGRESS_FILE, 'r', encoding='utf-8') as f:
                progress = json.load(f)
            
            self.collected_projects = progress.get('collected_projects', [])
            print(f"加载了 {len(self.collected_projects)} 个已收集的项目")
            
        except Exception as e:
            print(f"加载progress.json失败: {e}")
            sys.exit(1)
    
    def _load_options(self):
        """加载原始options.yml文件"""
        if not os.path.exists(OPTIONS_FILE):
            print(f"错误: {OPTIONS_FILE} 文件不存在")
            sys.exit(1)
        
        try:
            with open(OPTIONS_FILE, 'r', encoding='utf-8') as f:
                self.original_options = yaml.safe_load(f)
            
            # 保存原始outputDir
            self.original_output_dir = self.original_options.get('outputDir')
            print(f"原始outputDir: {self.original_output_dir}")
            
        except Exception as e:
            print(f"加载options.yml失败: {e}")
            sys.exit(1)
    
    def detect_classpath(self, project_name: str) -> List[str]:
        """
        检测项目的classpath
        通过分析所有.java文件中的package语句来获取classpath
        """
        project_path = os.path.join(JAVA_WEB_PROJECTS_DIR, project_name)
        
        classpaths = []
        package_patterns = []
        
        # 遍历项目目录下的所有.java文件
        for root, dirs, files in os.walk(project_path):
            # 跳过常见的非源码目录
            dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ['target', 'build', 'out', 'bin', 'node_modules']]
            
            for file in files:
                if not file.endswith('.java'):
                    continue
                
                java_file_path = os.path.join(root, file)
                
                try:
                    # 读取.java文件内容,查找package语句
                    with open(java_file_path, 'r', encoding='utf-8', errors='ignore') as f:
                        lines = f.readlines()
                    
                    for line in lines:
                        line = line.strip()
                        # 匹配package语句,格式如: package org.b3log.solo;
                        if line.startswith('package ') and line.endswith(';'):
                            # 提取包名
                            package_name = line[8:-1].strip()
                            if package_name and package_name not in package_patterns:
                                package_patterns.append(package_name)
                                # 将包名按点分割,获取第二和第三个部分作为classpath
                                package_parts = package_name.split('.')
                                
                                # 收集第二个和第三个字符串作为classpath(用户要求)
                                if len(package_parts) >= 2:
                                    second_part = package_parts[1]
                                    if second_part and second_part not in classpaths:
                                        classpaths.append(second_part)
                                
                                # if len(package_parts) >= 3:
                                #     third_part = package_parts[2]
                                #     if third_part and third_part not in classpaths:
                                #         classpaths.append(third_part)
                            break  # 通常package语句在文件开头,找到后即可退出内层循环
                        
                except Exception as e:
                    # 忽略单个文件读取错误
                    continue
        
        # 如果没有找到package语句,尝试基于目录结构推断
        if not classpaths:
            print(f"  警告: {project_name} 未找到package语句,尝试基于目录结构推断")
            
            java_source_path = os.path.join(project_path, "src", "main", "java")
            if os.path.exists(java_source_path):
                for root, dirs, files in os.walk(java_source_path):
                    java_files = [f for f in files if f.endswith('.java')]
                    if not java_files:
                        continue
                    
                    # 计算相对于src/main/java的路径
                    relative_path = os.path.relpath(root, java_source_path)
                    if relative_path == '.':
                        continue
                    
                    # 将路径转换为包名格式
                    path_parts = relative_path.split(os.sep)
                    for part in path_parts:
                        if part and part not in classpaths:
                            classpaths.append(part)
        
        # 去重并排序,确保一致性
        classpaths = sorted(list(set(classpaths)))
        
        if package_patterns:
            print(f"  检测到的package模式: {package_patterns[:3]}..." if len(package_patterns) > 3 else f"  检测到的package模式: {package_patterns}")
        
        return classpaths
    
    def get_jar_directory(self, project_name: str) -> str:
        """获取项目的jar目录路径"""
        jar_dir = os.path.join(JARS_OF_JAVA_WEB_PROJECTS_DIR, project_name)
        
        if not os.path.exists(jar_dir):
            print(f"  错误: {project_name} 的jar目录不存在: {jar_dir}")
            return None
        
        jar_files = [f for f in os.listdir(jar_dir) if f.endswith('.jar')]
        if not jar_files:
            print(f"  错误: {project_name} 目录下没有找到jar文件")
            return None
        
        print(f"  找到 {len(jar_files)} 个jar文件")
        return jar_dir
    
    def update_options_file(self, project_name: str):
        """更新options.yml文件中的outputDir"""
        new_output_dir = f"outputs_auto/{project_name}"
        
        try:
            # 更新outputDir
            self.original_options['outputDir'] = new_output_dir
            
            # 创建输出目录
            os.makedirs(new_output_dir, exist_ok=True)
            
            # 写入文件
            with open(OPTIONS_FILE, 'w', encoding='utf-8') as f:
                yaml.dump(self.original_options, f, default_flow_style=False, allow_unicode=True)
            
            print(f"  更新outputDir为: {new_output_dir}")
            
        except Exception as e:
            print(f"  更新options.yml失败: {e}")
            raise
    
    def restore_options_file(self):
        """恢复原始options.yml文件"""
        try:
            self.original_options['outputDir'] = self.original_output_dir
            
            with open(OPTIONS_FILE, 'w', encoding='utf-8') as f:
                yaml.dump(self.original_options, f, default_flow_style=False, allow_unicode=True)
            
            print(f"恢复outputDir为: {self.original_output_dir}")
            
        except Exception as e:
            print(f"恢复options.yml失败: {e}")
    
    def run_analysis(self, project_name: str, classpaths: List[str]) -> bool:
        """运行Tai-e分析"""
        jar_dir = self.get_jar_directory(project_name)
        if not jar_dir:
            return False
        
        # 构建classpath参数
        classpath_str = ','.join(classpaths) if classpaths else ''
        
        # 构建命令,--jarPath参数指定到项目jar目录
        cmd = [
            JAVA_COMMAND,
            "-jar", TAI_E_JAR,
            "--jarPath", jar_dir,
            "-k", classpath_str,
            "-n", project_name,
            "-r", "false",
            "-o", "options.yml",
            "-t", f"tmp/{project_name}"
        ]
        
        print(f"  执行命令: {' '.join(cmd)}")
        
        try:
            start_time = time.time()
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                timeout=TIMEOUT_SECONDS,
                cwd="/home/x/Codes/Myself/Research/code_audit_auto"
            )
            
            elapsed_time = time.time() - start_time
            
            if result.returncode == 0:
                print(f"  ✓ 分析完成,耗时: {elapsed_time:.1f}秒")
                return True
            else:
                print(f"  ✗ 分析失败,耗时: {elapsed_time:.1f}秒")
                print(f"    错误输出: {result.stderr[:200]}...")
                return False
                
        except subprocess.TimeoutExpired:
            print(f"  ✗ 分析超时(超过{TIMEOUT_SECONDS}秒)")
            return False
        except Exception as e:
            print(f"  ✗ 执行分析时发生异常: {e}")
            return False
    
    def run_batch_analysis(self):
        """批量运行分析"""
        print(f"开始批量分析 {len(self.collected_projects)} 个项目")
        print("="*60)
        
        success_count = 0
        failed_projects = []
        
        for i, project in enumerate(self.collected_projects, 1):
            project_name = project.get('project_name', '')
            if not project_name:
                print(f"项目 {i}: 项目名为空,跳过")
                continue
            
            print(f"\n项目 {i}/{len(self.collected_projects)}: {project_name}")
            print("-" * 40)
            
            # 检测classpath
            classpaths = self.detect_classpath(project_name)
            print(f"  检测到classpath: {classpaths}")
            
            if not classpaths:
                print(f"  警告: 未检测到classpath,将使用空字符串")
            
            # 更新options文件
            try:
                self.update_options_file(project_name)
            except Exception as e:
                print(f"  更新options失败,跳过项目: {e}")
                failed_projects.append(project_name)
                continue
            
            # 运行分析
            success = self.run_analysis(project_name, classpaths)
            
            if success:
                success_count += 1
            else:
                failed_projects.append(project_name)
        
        # 恢复原始options文件
        print(f"\n恢复原始配置文件...")
        self.restore_options_file()
        
        # 输出总结
        print("\n" + "="*60)
        print("批量分析完成!")
        print(f"总项目数: {len(self.collected_projects)}")
        print(f"成功: {success_count}")
        print(f"失败: {len(failed_projects)}")
        
        if failed_projects:
            print("\n失败项目:")
            for project in failed_projects:
                print(f"  - {project}")

def main() -> None:
    """主函数"""
    analyzer = TaiEAnalysisBatch()
    
    # 检查Tai-e jar文件是否存在
    if not os.path.exists(TAI_E_JAR):
        print(f"错误: {TAI_E_JAR} 文件不存在")
        sys.exit(1)
    
    # 检查Java命令是否存在
    if not os.path.exists(JAVA_COMMAND):
        print(f"错误: Java命令不存在: {JAVA_COMMAND}")
        sys.exit(1)
    
    analyzer.run_batch_analysis()
    # print(analyzer.detect_classpath("moxi624+mogu_blog_v2"))

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n用户中断操作")
    except Exception as e:
        print(f"程序执行失败: {e}")

通过以上代码能够对所有编译成功的项目执行静态分析任务

其检测结果保存在每一个项目名文件夹下的 microservice-taint-flows.txt文件中

对于不存在Taint通路的项目其内容为空,在大量项目中筛选存在有通路的可以使用以下脚本输出可能存在漏洞的项目

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
检查outputs目录下各个项目的microservice-taint-flows.txt文件内容
输出不为空的项目文件夹名
"""

import os
import sys
from pathlib import Path

def check_microservice_taint_flows(outputs_dir="outputs"):
    """
    遍历outputs目录下所有项目文件夹,检查microservice-taint-flows.txt文件内容
    输出不为空的项目文件夹名
    
    Args:
        outputs_dir: outputs目录路径,默认为"outputs"
    """
    if not os.path.exists(outputs_dir):
        print(f"错误: {outputs_dir} 目录不存在")
        return
    
    non_empty_projects = []
    total_projects = 0
    
    # 遍历outputs目录下的所有项目文件夹
    for project_folder in os.listdir(outputs_dir):
        project_path = os.path.join(outputs_dir, project_folder)
        
        # 确保是目录
        if not os.path.isdir(project_path):
            continue
            
        total_projects += 1
        taint_flows_file = os.path.join(project_path, "microservice-taint-flows.txt")
        
        # 检查文件是否存在
        if not os.path.exists(taint_flows_file):
            print(f"项目 {project_folder}: 文件不存在 - {taint_flows_file}")
            continue
        
        try:
            # 读取文件内容
            with open(taint_flows_file, 'r', encoding='utf-8') as f:
                content = f.read().strip()
            
            # 检查内容是否为空
            if content:
                non_empty_projects.append(project_folder)
                print(f"✓ 项目 {project_folder}: 有内容 (文件大小: {len(content)} 字符)")
            else:
                print(f"- 项目 {project_folder}: 文件为空")
                
        except Exception as e:
            print(f"✗ 项目 {project_folder}: 读取文件失败 - {e}")
    
    # 输出统计信息
    print("\n" + "="*60)
    print(f"检查完成!")
    print(f"总项目数: {total_projects}")
    print(f"有内容的项目数: {len(non_empty_projects)}")
    print(f"空文件或无文件项目数: {total_projects - len(non_empty_projects)}")
    
    if non_empty_projects:
        print("\n不为空的项目文件夹名:")
        print("-" * 30)
        for project in sorted(non_empty_projects):
            print(project)
    else:
        print("\n没有找到包含内容的项目文件夹")

def main():
    """主函数"""
    outputs_dir = "outputs"
    
    # 如果命令行参数指定了outputs目录
    if len(sys.argv) > 1:
        outputs_dir = sys.argv[1]
    
    print(f"开始检查目录: {outputs_dir}")
    print("="*60)
    
    check_microservice_taint_flows(outputs_dir)

if __name__ == "__main__":
    main()

对于最终的检测结果也算是有所收获

Conclusion

上文对Mscan针对微服务应用这一特定应用进行了建模,针对微服务应用中的各个服务间通过OpenFeign、Grpc、Kafka以及RabbitMQ等框架进行通信的方式构建了一个服务依赖图,用于表征数据流的传递路径,进一步的进行污点传播进行外部可控的Web漏洞检测。通过对类似于OpenFeign等框架的通信机制的分析,使用Tai-e插件系统提供的生命周期API构建调用边,对于一些其他未使用这类框架进行服务间通信的微服务应用可以采用类似的方式扩展的构建调用边以便于支持其漏洞检测任务。同时也对静态分析框架在完整流程的重要阶段过程进行了阐述,也即是Soot程序分析,以及指针分析算法的实现。最后也是基于静态分析框架为核心构建了一个 clone-compile-scan全流程的workflow。