devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

DependencyCheck+Jenkins扫描JAVA第三方依赖(CVE)漏洞_dependency-check

作者：木道寻08 | 2024-08-13 23:09:24

赞

踩

dependency-check

原理说明：首先使用DependencyCheck更新漏洞库到本地，然后DependencyCheck扫描扫描项目，得到一个json报告，然后再使用json报告填充我们的自定义模板，最后输出填充后的模板为漏洞报告。至于jenkins只是最后帮我们实现全自动扫描、输出的一个工具而已。

一、部署DependencyCheck

1、DependencyCheck是什么

  • Dependency-Check 是 OWASP（Open Web Application Security Project）的一个实用开源程序，用于识别项目依赖项并检查是否存在任何已知的，公开披露的漏洞。目前，已支持Java、.NET、Ruby、Node.js、Python等语言编写的程序，并为C/C++构建系统（autoconf和cmake）提供了有限的支持。而且该工具还是OWASP Top 10的解决方案的一部分。
  • Dependency-Check 支持面广（支持多种语言）、可集成性强，作为一款开源工具，在多年来的发展中已经支持和许多主流的软件进行集成，比如：命令行、Ant、Maven、Gradle、Jenkins、Sonar等；具备使用方便，落地简单等优势。

2、下载DependencyCheck

官方网站：OWASP Dependency-Check | OWASP Foundation

3、安装DependencyCheck

开箱即用：

        将zip压缩包解压即可，我就放这里了：/root/dependency-check。执行bin目录下的dependency-check.bat或者dependency-check.sh。

命令如下：

  1. dependency-check.sh --project "第三方依赖CVE漏洞扫描报告" --scan "**/*.jar" -n -f JSON -o "第三方依赖CVE漏洞扫描报告.json"
  2.  
  3. --project 给这次扫描的项目起个名称
  4. --scan    要扫描的文件路径
  5. -n        此次扫描不更新漏洞库：不加这个会先去更新漏洞库，然后再进行扫描
  6. -f        要输出的报告格式，有HTML ，JSON等
  7. -o        扫描报告的存放路径

二、本地漏洞库搭建（NVD+CNNVD）

1、获取nvd漏洞库

这里要使用大佬的开源工具：nist-data-mirror.jar。开源地址：stevespringett/nist-data-mirror: A simple Java command-line utility to mirror the CVE JSON data from NIST. (github.com)

为了方便管理我把这个工具放在这里：/root/dependency-check/data/nist-data-mirror.jar。加载nvd漏洞库（第一次有点慢，从2000年开始的）：

java -jar /root/dependency-check/data/nist-data-mirror.jar /root/dependency-check/data/nvdcache

将更新下来的JSON数据提取，保存在数据库表里面，核心代码：

  1. package com.yunhuang.autosafe.common.service.impl;
  2.  
  3. import cn.hutool.core.date.DateUtil;
  4. import cn.hutool.core.io.resource.ClassPathResource;
  5. import cn.hutool.json.JSONObject;
  6. import cn.hutool.json.JSONUtil;
  7. import com.alibaba.fastjson.JSON;
  8. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  9. import com.yunhuang.autosafe.common.cve.CveObj;
  10. import com.yunhuang.autosafe.common.entity.Cve;
  11. import com.yunhuang.autosafe.common.mapper.CveMapper;
  12. import com.yunhuang.autosafe.common.service.CveService;
  13. import org.apache.commons.io.FileUtils;
  14. import org.springframework.stereotype.Service;
  15.  
  16. import java.io.*;
  17. import java.nio.file.Files;
  18. import java.nio.file.Paths;
  19. import java.util.ArrayList;
  20. import java.util.List;
  21.  
  22.  
  23. @Service
  24. public class CveServiceImpl extends ServiceImpl<CveMapper, Cve> implements CveService {
  25.  
  26.     /**
  27.      * 拉去cve漏洞数据库
  28.      * @param loadType 0-全量初始化 1-增量更新
  29.      */
  30.     @Override
  31.     public void loadCveData(Integer loadType) {
  32.         String workspace = System.getProperty("user.dir");
  33.         String nvdcachePath = workspace + "/nvdcache";
  34.         System.out.println("工作空间="+workspace);
  35.         //1、拉取NVD的cve漏洞文件
  36.         syncCveList(workspace,nvdcachePath);
  37.  
  38.         //2、将拉取到的json文件进行解析并提取为对象，转存mysql
  39.         if(0==loadType){
  40.             readFilesAll(nvdcachePath);
  41.         }else if(1==loadType){
  42.             updateRecentCve(nvdcachePath);
  43.         }
  44.     }
  45.  
  46.     /**
  47.      * 拉取NVD的cve漏洞文件(json文件)
  48.      * @param workspace       工作空间：默认当前jar的路径
  49.      * @param nvdcachePath    存储漏洞库文件（json文件）的路径
  50.      */
  51.     public void syncCveList(String workspace,String nvdcachePath) {
  52.         //1、检查缓存目录是否存在
  53.         File nvdcacheFile = new File(nvdcachePath);
  54.         if(!nvdcacheFile.exists()){
  55.             System.out.println("缓存目录不存在，创建！");
  56.             nvdcacheFile.mkdirs();
  57.         }
  58.  
  59.         String nistDataMirror = workspace + "/nist-data-mirror.jar";
  60.         File nistDataMirrorFile = new File(nistDataMirror);
  61.         if(!nistDataMirrorFile.exists()){
  62.             System.out.println("nist-data-mirror.jar不存在，创建！");
  63.             try{
  64.                 ClassPathResource classPathResource = new ClassPathResource("utils/nist-data-mirror.jar");
  65.                 InputStream inputStream = classPathResource.getStream();
  66.                 String destPath = workspace + "/nist-data-mirror.jar";
  67.  
  68.                 FileUtils.copyInputStreamToFile(inputStream, new File(destPath));
  69.  
  70.             }catch (Exception e){
  71.                 e.printStackTrace();
  72.             }
  73.         }
  74.  
  75.  
  76.         //1、拉取NVD的cve漏洞文件
  77.         String command = "java -jar "+workspace+"/nist-data-mirror.jar "+nvdcachePath;
  78.  
  79.         try {
  80.             Process process = Runtime.getRuntime().exec(command);
  81.  
  82.             // 读取命令执行的输出
  83.             InputStream inputStream = process.getInputStream();
  84.             BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
  85.  
  86.             String line;
  87.             while ((line = reader.readLine()) != null) {
  88.                 System.out.println(line);
  89.             }
  90.  
  91.             // 等待命令执行结束
  92.             int exitCode = process.waitFor();
  93.             System.out.println("命令执行结束，退出码：" + exitCode);
  94.  
  95.         } catch (IOException | InterruptedException e) {
  96.             e.printStackTrace();
  97.         }
  98.     }
  99.  
  100.  
  101.  
  102.  
  103.  
  104.     private void readFilesAll(String nvdcachePath){
  105.         System.out.println("------------全量初始化------------");
  106.         File nvdcacheFile = new File(nvdcachePath);
  107.         File[] files = nvdcacheFile.listFiles((dir, name) -> name.toLowerCase().endsWith(".json"));
  108.         for(File f : files){
  109.             System.out.println(f.getAbsolutePath());
  110.             parseJson(f.getAbsolutePath());
  111.             System.out.println("");
  112.         }
  113.         System.out.println("------------全量初始化-完成------------");
  114.     }
  115.  
  116.     private void updateRecentCve(String nvdcachePath){
  117.         System.out.println("------------增量更新------------");
  118.         File nvdcacheFile = new File(nvdcachePath);
  119.         File[] files = nvdcacheFile.listFiles((dir, name) -> name.toLowerCase().endsWith(DateUtil.thisYear()+".json") || name.toLowerCase().endsWith("modified.json") || name.toLowerCase().endsWith("recent.json"));
  120.         for(File f : files){
  121.             System.out.println(f.getAbsolutePath());
  122.             parseJson(f.getAbsolutePath());
  123.             System.out.println("");
  124.         }
  125.         System.out.println("------------增量更新-完成------------");
  126.     }
  127.  
  128.  
  129.     private void parseJson(String filePath){
  130.         try {
  131.             String jsonStr = new String( Files.readAllBytes( Paths.get(filePath)));
  132.             JSONObject jsonObject = JSONUtil.parseObj(jsonStr);
  133.             String CVE_Items = jsonObject.getStr("CVE_Items");
  134.             List<CveObj> cveObjs = JSONUtil.toList(CVE_Items, CveObj.class);
  135.  
  136.             List<Cve> list = new ArrayList<>();
  137.             // 对解析后的对象数组进行操作
  138.             for (CveObj obj : cveObjs) {
  139.                 Cve cve = new Cve();
  140.                 cve.setId(obj.getCve().getCVE_data_meta().getID());
  141.                 try{
  142.                     cve.setSeverity(obj.getImpact().getBaseMetricV2().getSeverity()+"");
  143.                 }catch (Exception e){
  144.  
  145.                 }
  146.                 cve.setDescription(JSON.toJSONString(obj.getCve().getDescription().getDescription_data()).replaceAll("'",""));
  147.                 cve.setPublishedDate(DateUtil.parseDate(obj.getPublishedDate()));
  148.                 cve.setLastModifiedDate(DateUtil.parseDate(obj.getLastModifiedDate()));
  149.  
  150.                 list.add(cve);
  151.             }
  152.  
  153.             this.saveOrUpdateBatch(list);
  154.         } catch (IOException e) {
  155.             e.printStackTrace();
  156.         }
  157.     }
  158. }

2、获取cnnvd漏洞库

官网地址：国家信息安全漏洞库 (cnnvd.org.cn)

CNNVD是我们国家的信息安全漏洞库，咱们这个漏洞库不仅仅收录了NVD的漏洞数据（CVE），还收录咱们国内的漏洞信息（CNNVD），也就是说同样一条漏洞信息，CNNVD的漏洞数据上面既有CVE漏洞编码，也有CNNVD编码，而且描述信息还是中文的。

获取方式：

3、转换为自定义漏洞库

CNNVD漏洞数据库下载后是xml格式的文件，我们需要写代码将xml里面我们需要的数据提取出来，保存在数据库表里面

  1. @GetMapping
  2.     public void insertCnnvd(int type) throws JAXBException {
  3.  
  4.  
  5.         if(type==0){
  6.             for(int i=1999;i<=2023;i++){
  7.                 System.out.println("-------->开始读取"+i+"年数据：");
  8.                 List<Cnnvd> nvdList = parseXml(i);
  9.                 System.out.println("-------->成功读取"+i+"年数据："+nvdList.size());
  10.                 cnnvdService.saveOrUpdateBatch(nvdList);
  11.                 System.out.println("-------->成功写入数据："+nvdList.size());
  12.                 System.out.println("");
  13.                 System.out.println("");
  14.             }
  15.         }else{
  16.             System.out.println("-------->开始读取"+DateUtil.thisYear()+"年数据：");
  17.             List<Cnnvd> cnnvdList = parseXml(2023);
  18.             System.out.println("-------->成功读取"+DateUtil.thisYear()+"年数据："+cnnvdList.size());
  19.             cnnvdService.saveOrUpdateBatch(cnnvdList);
  20.             System.out.println("-------->成功写入数据："+cnnvdList.size());
  21.         }
  22.     }
  23.  
  24.     public List<Cnnvd> parseXml(int fileName) throws JAXBException {
  25.         //可能的问题：[org.xml.sax.SAXParseException; lineNumber: 2292; columnNumber: 191; 元素类型 "use" 必须由匹配的结束标记 "</use>" 终止。]] with root cause
  26.         //解决的方案：在内网的签名添加字符串：<![CDATA[             在内网的结尾添加字符串：]]>
  27.         InputStream stream = this.getClass().getClassLoader().getResourceAsStream("cnnvd/"+fileName+".xml");
  28.  
  29.         JAXBContext jaxbContext = JAXBContext.newInstance(VulnerabilityList.class);
  30.         Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
  31.         VulnerabilityList vulnerabilityList = (VulnerabilityList) jaxbUnmarshaller.unmarshal(stream);
  32.         List<Cnnvd> vulnerabilities = vulnerabilityList.vulnerabilities;
  33.  
  34.         return vulnerabilities;
  35.     }
  1. @Data
  2. @XmlRootElement(name = "entry")
  3. @XmlAccessorType(XmlAccessType.FIELD)
  4. public class Cnnvd implements Serializable {
  5.     @TableId(type = IdType.INPUT)
  6.     @XmlElement(name = "vuln-id")
  7.     public String id;
  8.     @XmlElement(name = "name")
  9.     public String name;
  10.     @XmlElement(name = "published")
  11.     public String published;
  12.     @XmlElement(name = "modified")
  13.     public String modified;
  14.     @XmlElement(name = "source")
  15.     public String source;
  16.     @XmlElement(name = "severity")
  17.     public String severity;
  18.     @XmlElement(name = "vuln-type")
  19.     public String vulnType;
  20.     @XmlElement(name = "vuln-descript")
  21.     public String description;
  22.     @XmlElement(name = "cve-id")
  23.     public String cveId;
  24.     @XmlElement(name = "bugtraq-id")
  25.     public String bugtraqId;
  26.     @XmlElement(name = "vuln-solution")
  27.     public String solution;
  28. }

三、使用DependencyCheck扫描

/root/dependency-check/bin/dependency-check.sh --project "test-服务端第三方依赖CVE漏洞扫描报告" --scan "**/*.jar" -n -f JSON -o "/var/www/html/test-服务端第三方依赖CVE漏洞扫描报告.json"

四、输出自定义扫描报告

1、使用pot-tl自定义word模板

2、解析json生成word报告

将上面扫描的“test-服务端第三方依赖CVE漏洞扫描报告.json”数据解析出来，填充到我们的自定义模板中，最终生成我们的word报告。

  1. /**
  2.      * 根据json报告解析漏洞信息并入库：方便后续直接构建word和excel
  3.      * @param name   报告名称
  4.      * @param sourePath   json报告路径
  5.      * @param reportPath  word报告路径
  6.      * @param gitHttpUrl  git的http地址
  7.      * @param gitBranch   git分支
  8.      * @return
  9.      * @throws IOException
  10.      */
  11.     @GetMapping
  12.     public String vulScanReport(String name, String sourePath,String reportPath,String gitHttpUrl,String gitBranch) throws IOException {
  13.         //解析扫描的json报告，并将数据写入数据库
  14.         int num = cnnvdService.analysisCveJsonv2(name,sourePath, gitHttpUrl, gitBranch);
  15.         if(num>0){
  16.             //读取扫描的漏洞数据，填充自定义模板，生成word报告
  17.             String fileName = cnnvdService.createWord(name,reportPath,gitHttpUrl,gitBranch);
  18.             return fileName;
  19.         }else{
  20.             return "";
  21.         }
  22.     }
  1. package com.yunhuang.autosafe.common.service.impl;
  2.  
  3.  
  4. import cn.hutool.core.date.DateUtil;
  5. import cn.hutool.json.JSONArray;
  6. import cn.hutool.json.JSONObject;
  7. import cn.hutool.json.JSONUtil;
  8. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  9. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  10. import com.deepoove.poi.XWPFTemplate;
  11. import com.deepoove.poi.config.Configure;
  12. import com.deepoove.poi.plugin.table.LoopRowTableRenderPolicy;
  13. import com.deepoove.poi.util.PoitlIOUtils;
  14. import com.yunhuang.autosafe.common.entity.*;
  15. import com.yunhuang.autosafe.common.mapper.CnnvdMapper;
  16. import com.yunhuang.autosafe.common.service.*;
  17. import lombok.Data;
  18. import org.apache.commons.lang3.StringUtils;
  19. import org.springframework.beans.factory.annotation.Autowired;
  20. import org.springframework.data.redis.core.RedisTemplate;
  21. import org.springframework.stereotype.Service;
  22. import javax.annotation.Resource;
  23. import java.io.*;
  24. import java.util.*;
  25. import java.util.function.Function;
  26. import java.util.stream.Collectors;
  27.  
  28.  
  29. @Service
  30. public class CnnvdServiceImpl extends ServiceImpl<CnnvdMapper, Cnnvd> implements CnnvdService {
  31.  
  32.     @Autowired
  33.     private NvdMyService nvdMyService;
  34.     @Autowired
  35.     private CveService cveService;
  36.     @Autowired
  37.     private ScanDependencieService dependencieService;
  38.     @Autowired
  39.     private ScanVulnerabilitieService vulnerabilitieService;
  40.     @Resource
  41.     private RedisTemplate redisTemplate;
  42.  
  43.     private final static String REDIS_NVD_KEY = "cve_data";
  44.  
  45.     /**
  46.      * 根据json报告解析漏洞信息并入库：方便后续直接构建word和excel
  47.      * @param name   报告名称
  48.      * @param sourePath   json报告路径
  49.      * @param gitHttpUrl  git的http地址
  50.      * @param gitBranch   git分支
  51.      * @return
  52.      * @throws IOException
  53.      */
  54.     @Override
  55.     public Integer analysisCveJsonv2(String name, String sourePath, String gitHttpUrl, String gitBranch) throws IOException {
  56.         //数据库统一记录时间
  57.         Date createTime = new Date();
  58.         String jsonStr = readFileContent(sourePath);
  59.         JSONObject jsonObject = JSONUtil.parseObj(jsonStr);
  60.  
  61.         //依赖
  62.         String dependencies = jsonObject.getStr("dependencies");
  63.         JSONArray array = JSONUtil.parseArray(dependencies);
  64.  
  65.         //依赖下的漏洞
  66.         List<ScanDependencie> dependencieList = JSONUtil.toList(array, ScanDependencie.class);
  67.         System.out.println("--------------->依赖项总数："+dependencieList.size());
  68.  
  69.         //漏洞详情列表
  70.         List<ScanDependencie> dependencieVulList = new ArrayList<>();
  71.         //漏洞清单汇总
  72.         List<ScanVulnerabilitie> vulnerabilitiesAll = new ArrayList<>();
  73.         //扫描到的漏洞清单
  74.         List<String> cveScanList = new ArrayList<>();
  75.  
  76.  
  77.         int i = 1;
  78.  
  79.         //遍历依赖：构建导出数据
  80.         for(ScanDependencie d :dependencieList){
  81.             if(d.getVulnerabilities()==null || d.getVulnerabilities().size()==0) continue;
  82.  
  83.             int pindex = i++;
  84.             String depId = UUID.randomUUID().toString().replaceAll("-","");
  85.             d.setId(depId);
  86.             d.setName(name);
  87.             d.setSortIndex(pindex);
  88.             d.setFileName(d.getFileName().replaceAll(" ",""));
  89.             d.setGitHttpUrl(gitHttpUrl);
  90.             d.setGitBranch(gitBranch);
  91.             d.setScanDate(createTime);
  92.             if(StringUtils.isNotBlank(d.getDescription())) d.setDescription(d.getDescription().trim());
  93.  
  94.             int m = 1;
  95.             //遍历依赖下的漏洞
  96.             List<ScanVulnerabilitie> vulnerabilities = d.getVulnerabilities();
  97.             for(ScanVulnerabilitie vul : vulnerabilities){
  98.                 if(vul.getName().indexOf("CVE")==-1) continue;
  99.  
  100.                 //添加到扫描漏洞清单
  101.                 cveScanList.add(vul.getName());
  102.  
  103.                 int index = m++;
  104.                 vul.setDependencieId(depId);
  105.                 vul.setSortIndex(index);
  106.                 vul.setSortIndexStr(pindex+"."+index);
  107.                 vul.setScanDate(createTime);
  108.  
  109.                 vulnerabilitiesAll.add(vul);
  110.             }
  111.  
  112.             dependencieVulList.add(d);
  113.         }
  114.  
  115.  
  116.         //清除之前的数据
  117.         QueryWrapper<ScanDependencie> wrapper = new QueryWrapper<>();
  118.         wrapper.eq("git_http_url",gitHttpUrl);
  119.         List<ScanDependencie> oldList = dependencieService.list(wrapper);
  120.         List<String> depIds = oldList.stream().map(ScanDependencie::getId).collect(Collectors.toList());
  121.  
  122.         if(depIds.size()>0){
  123.             QueryWrapper<ScanVulnerabilitie> wrapper2 = new QueryWrapper<>();
  124.             wrapper2.in("dependencie_id",depIds);
  125.             vulnerabilitieService.remove(wrapper2);
  126.         }
  127.         dependencieService.remove(wrapper);
  128.  
  129.         //保存扫描到的依赖数据：dependencieVulList
  130.         dependencieService.saveBatch(dependencieVulList);
  131.         //保存扫描到的依赖数据：vulnerabilitiesAll
  132.         vulnerabilitieService.saveBatch(vulnerabilitiesAll);
  133.         System.out.println("--------------->有漏洞的依赖项："+dependencieVulList.size());
  134.         System.out.println("--------------->漏洞总数："+vulnerabilitiesAll.size());
  135.         System.out.println("");
  136.         return vulnerabilitiesAll.size();
  137.     }
  138.  
  139.     @Override
  140.     public String createWord(String name, String reportPath, String gitHttpUrl, String gitBranch) throws IOException {
  141.  
  142.         //所有的有漏洞的依赖
  143.         List<ScanDependencie> dependencieList = new ArrayList<>();
  144.         //所有的漏洞清单
  145.         List<ScanVulnerabilitie> vulList = new ArrayList<>();
  146.         //漏洞清单分组
  147.         Map<String, List<ScanVulnerabilitie>> listMap = new HashMap<>();
  148.         //漏洞编码
  149.         List<String> cveIds = new ArrayList<>();
  150.         //对应的cnnvd信息（中文解释）
  151.         Map<String, Cnnvd> cnnvdMap = new HashMap<>();
  152.         //nvd漏洞原始信息（英文内容）
  153.         Map<String, Cve> cveMap = new HashMap<>();
  154.  
  155.         QueryWrapper<ScanDependencie> wrapper1 = new QueryWrapper();
  156.         wrapper1.eq("name",name).eq("git_http_url",gitHttpUrl).orderByAsc("sort_index");
  157.         dependencieList = dependencieService.list(wrapper1);
  158.  
  159.         List<String> depIds = dependencieList.stream().map(ScanDependencie::getId).collect(Collectors.toList());
  160.         if(depIds==null || depIds.size()==0) return null;
  161.  
  162.         QueryWrapper<ScanVulnerabilitie> wrapper2 = new QueryWrapper<>();
  163.         wrapper2.in("dependencie_id",depIds).orderByAsc("id");
  164.         vulList = vulnerabilitieService.list(wrapper2);
  165.         //漏洞根据依赖id分组
  166.         listMap = vulList.stream().collect(Collectors.groupingBy(ScanVulnerabilitie::getDependencieId));
  167.  
  168.         cveIds = vulList.stream().map(ScanVulnerabilitie::getName).distinct().collect(Collectors.toList());
  169.         //根据漏洞编码查询cnnvd漏洞库
  170.         QueryWrapper<Cnnvd> wrapper3 = new QueryWrapper<>();
  171.         wrapper3.in("cve_id",cveIds);
  172.         List<Cnnvd> nvdList = this.list(wrapper3);
  173.         cnnvdMap = nvdList.stream().collect(Collectors.toMap(Cnnvd::getCveId, Function.identity()));
  174.  
  175.         //根据漏洞编码查询nvd漏洞库
  176.         QueryWrapper<Cve> wrapper4 = new QueryWrapper<>();
  177.         wrapper4.in("id",cveIds);
  178.         List<Cve> cveList = cveService.list(wrapper4);
  179.         cveMap = cveList.stream().collect(Collectors.toMap(Cve::getId, Function.identity()));
  180.  
  181.  
  182.         //--------------------------------开始准备word数据----------------------------------//
  183.         for(ScanDependencie d : dependencieList){
  184.  
  185.             if(!listMap.containsKey(d.getId())) continue;
  186.             List<ScanVulnerabilitie> vuls = listMap.get(d.getId());
  187.             for(ScanVulnerabilitie vul : vuls){
  188.                 if(cnnvdMap.containsKey(vul.getName())){
  189.                     Cnnvd cnnvd = cnnvdMap.get(vul.getName());
  190.                     if(cnnvd==null) continue;
  191.  
  192.                     vul.setSeverity(cnnvd.getSeverity());
  193.                     vul.setVulnType(cnnvd.getVulnType());
  194.                     vul.setCnnvd(cnnvd.getId());
  195.                     vul.setTitle(cnnvd.getName());
  196.                     vul.setDescription(cnnvd.getDescription());
  197.                 }else{
  198.                     Cve cve = cveMap.get(vul.getName());
  199.                     if(cve==null) continue;
  200.  
  201.                     vul.setSeverity(cve.getSeverity());
  202.                     vul.setDescription(cve.getDescription());
  203.                 }
  204.             }
  205.  
  206.             d.setVulnerabilities(vuls);
  207.         }
  208.  
  209.  
  210.  
  211.  
  212.  
  213.         Map<String,Object> map = new HashMap<>();
  214.         map.put("gitHttpUrl", gitHttpUrl);
  215.         map.put("gitBranch", gitBranch);
  216.         map.put("reportDate", DateUtil.today());
  217.         map.put("projectName",name);
  218.         map.put("vulnerabilitieDependencie",dependencieList.size());
  219.         map.put("vulnerabilitieNum",vulList.size());
  220.         map.put("dependencieList",dependencieList);
  221.         map.put("depList",dependencieList);
  222.         map.put("vulList",vulList);
  223.  
  224.         LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
  225.         Configure config = Configure.builder().bind("depList", policy).bind("vulList", policy).build();
  226.  
  227.         String fileName = name+"-第三方依赖CVE漏洞扫描报告.docx";
  228.         String outputFile = reportPath+fileName;
  229.         XWPFTemplate template = XWPFTemplate.compile(this.getClass().getClassLoader().getResourceAsStream("templates/第三方依赖CVE漏洞扫描报告模板.docx"),config).render(map);
  230.         template.write(new FileOutputStream(outputFile));
  231.         PoitlIOUtils.closeQuietlyMulti(template);
  232.         return fileName;
  233.     }
  234.  
  235.  
  236.  
  237.  
  238.  
  239.     public String readFileContent(String filePath) throws IOException {
  240.  
  241.         // 指定文件路径
  242.         File file = new File(filePath);
  243.  
  244.         // 创建 BufferedReader 和 InputStreamReader 实例以读取文件
  245.         FileInputStream fileInputStream = new FileInputStream(file);
  246.         InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
  247.         BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
  248.  
  249.         // 创建 StringBuilder 实例存储文件内容
  250.         StringBuilder sb = new StringBuilder();
  251.         String line;
  252.         while ((line = bufferedReader.readLine()) != null) {
  253.             sb.append(line);
  254.             sb.append("\n"); // 每行后添加换行符
  255.         }
  256.  
  257.         // 关闭 BufferedReader 和 InputStreamReader
  258.         bufferedReader.close();
  259.         inputStreamReader.close();
  260.         fileInputStream.close();
  261.  
  262.         // 返回文件内容的字符串形式
  263.         return sb.toString();
  264.     }
  265.  
  266. }

五、使用jenkins实现自动化

我这里是使用jenkins的流水线SCM

  1. def nameStr = 'xxx'
  2. def gitHttpUrl = 'https://git.xxx.com/aaaa/xxx.git'
  3. def gitsshUrl = 'git@git.xxx.com:aaaa/xxx.git'
  4. def gitBranch = 'master'
  5.  
  6. pipeline {
  7.     agent any
  8.     stages {
  9.         stage('拉取代码') {
  10.             steps {
  11.                 script{
  12.                     echo '----拉取代码----'
  13.                     git branch: gitBranch, credentialsId: 'xxxxxxxx', url: gitHttpUrl
  14.                 }
  15.             }
  16.         }
  17.         stage('编译jar包') {
  18.             steps {
  19.                 echo '----编译jar包----'
  20.                 sh 'mvn clean package -DskipTests=true'
  21.             }
  22.         }
  23.         stage('依赖检查') {
  24.             steps {
  25.                 script{
  26.                     echo '----第三方jar包依赖检查-----开始'
  27.                     sh '/root/dependency-check/bin/dependency-check.sh --project "'+nameStr+'-服务端第三方依赖CVE漏洞扫描报告" --scan "**/*.jar" -n -f JSON -o "/var/www/html/'+nameStr+'-服务端第三方依赖CVE漏洞扫描报告.json"'
  28.                     echo '----第三方jar包依赖检查-----结束'
  29.                 }
  30.             }
  31.         }
  32.         stage('生成报告') {
  33.             steps {
  34.                 script{
  35.                     echo '----开始-生成报告----'
  36.                     def response = sh(returnStdout: true, script: 'curl -G -s  --data-urlencode "name='+nameStr+'"  --data-urlencode  "sourePath=/var/www/html/'+nameStr+'-服务端第三方依赖CVE漏洞扫描报告.json" --data-urlencode "reportPath=/var/www/html/" --data-urlencode "gitHttpUrl='+gitHttpUrl+'"  --data-urlencode "gitBranch='+gitBranch+'"  "http://localhost:9000/api/v1/report"')
  37.                     echo response
  38.                     echo '报告访问地址：http://192.168.1.x/'+response
  39.                     echo '----结束-生成报告----'
  40.                 }
  41.             }
  42.         }
  43.     }
  44. }

六、补充两句

1、DependencyCheck有对应的maven插件，开发者可以单独集成使用。

2、DependencyCheck可以直接输出html报告，全英文的，有很多信息我们并不关心。

3、本篇文章里面涉及到的提取cve数据和cnnvd数据到数据，解析json和生成word报告，我单独做了一个服务全部整合进去了，jenkins自动化其实就是拉代码，打jar包，调用DependencyCheck扫描jar包并输出json报告，然后再调用我自己整个的这个服务，把报告的名称，git仓库地址，json漏洞报告的路径，以及word最终存放的路径作为参数传进去。最后在jenkins控制点打印一个下载地址。方便下载扫描报告。

4、后续我有时间了会将这个项目整理一下放到开源网站上，静待后续...

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/976835
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号