Docker镜像扫描器的实现

本文主要通过对analyze-local-images和clair的源码剖析讲解Docker镜像扫描器的简易实现。

Docker镜像简介

这篇文章算抛砖引玉,给大家提供一些简单的思路。

首先要做Docker镜像扫描,我们必须要懂Docker镜像是怎么回事。

c1.png

Docker镜像是由文件系统叠加而成。最底层是bootfs,之上的部分为rootfs。

bootfs是docker镜像最底层的引导文件系统,包含bootloader和操作系统内核。

rootfs通常包含一个操作系统运行所需的文件系统。这一层作为基础镜像。

在基础镜像之上,会加入各种镜像,如emacs、apache等。

如何分析镜像

对镜像进行分析,无外乎静态分析和动态分析两种方式。而开源的可参考的实现有

专注于静态分析的Clair和容器关联分析与监控的Weave Scope。但Weave Scope似乎跟安全关系不太大,下面笔者会给出一些动态分析的思路。

首先,我们看以下威名远扬的Clair。Clair目前仅支持appc和docker容器的静态分析。

Clair整体架构如下:

c2.png

Clair包含以下核心模块。

获取器(Fetcher)- 从公共源收集漏洞数据

检测器(Detector)- 指出容器镜像中包含的Feature

容器格式器(Image Format)- Clair已知的容器镜像格式,包括Docker,ACI

通知钩子(Notification Hook)- 当新的漏洞被发现时或者已经存在的漏洞发生改变时通知用户/机器

数据库(Databases)- 存储容器中各个层以及漏洞

Worker – 每个Post Layer都会启动一个worker进行Layer Detect

编译与使用

Clair目前共发布了21个release。我们这里使用第20个release版本,既V2.0.0进行源码剖析。

为了减少在编译过程中的错误,建议使用ubuntu进行编译。并在编译之前,确保git,bzr,rpm,xz等模块已经安装好。Golang版本使用1.8.3以上。并确保已经安装好postgresql,笔者使用的版本为9.5. 建议你也与笔者保持一致。

使用go build github.com/coreos/clair/cmd/clair编译clair

使用gobuild github.com/coreos/analyze-local-images 编译analyze-local-images

其中Clair作为server端,analyze-local-images作为Client端。

简单使用如下。通过analyze-local-images分析nginx:latest镜像。

c3.png

c4.png

两者交互的整个流程可以简化为:

c5.png

Analyze-local-images源码分析

在使用analyze-local-images时,我们可以指定一些参数。

analyze-local-images -endpoint "http://10.28.182.152:6060"

 -my-address "10.28.182.151" nginx:latest  

其中,endpoint为clair主机的ip地址。my-address为运行analyze-local-images这个客户端的地址。

postLayerURI是向clair API V1发送数据库的路由,getLayerFeaturesURI是从clair API V1获取漏洞信息的路由。

analyze-local-images在主函数调用intMain()函数,而intMain会首先去解析用户的输入参数。例如刚才的endpoint。

Analyze-local-images是主要执行流程为:

main()->intMain()->AnalyzeLocalImage()—>analyzeLayer()->getLayer()

func intMain() int {    

    //解析命令行参数,并给刚才定义的一些全局变量赋值。    

    ......    

        //创建一个临时目录    

    tmpPath, err := ioutil.TempDir("", "analyze-local-image-")    

    //在/tmp目录下创建以analyze-local-image-开头的文件夹。    

 //为了能够清楚的观察/tmp下目录的变化,我们将defer os.RemoveAll(tmpPath)这句注释掉,再重新编译。    

    

    ......    

    //调用AnalyzeLocalImage方法分析镜像    

    go func() {    

   analyzeCh <- AnalyzeLocalImage(imageName, minSeverity, *flagEndpoint, *flagMyAddress, tmpPath)    

    }()    

镜像被解压到tmp目录下的目录结构如下:

c6.png

analyze-local-images与clair服务端进行交互的两个主要方法为analyzeLayer和getLayer。analyzeLayer向clair发送JSON格式的数据。而getLayer用来获取clair的请求。并将json格式数据解码后格式化输出。

func AnalyzeLocalImage(imageName string, minSeverity database.Severity, endpoint, myAddress, tmpPath string) error {    

    //保存镜像到tmp目录下    

    //调用save方法    

    //save方法的原理就是使用docker save 镜像名先将镜像打包成tar文件    

    //然后使用tar命令将文件再解压到tmp文件中。    

    err := save(imageName, tmpPath)    

    .......    

    //调用historyFromManifest方法,读取manifest.json文件获取每一层的id名,保存在layerIDs中。    

    //如果从manifest.json文件中获取不到,则读取历史记录    

        

    layerIDs, err := historyFromManifest(tmpPath)    

    if err != nil {    

    layerIDs, err = historyFromCommand(imageName)    

    }    

    ......    

    //如果clair不在本机,则在analyze-local-images上开启HTTP服务,默认端口为9279    

    ......    

    //分析每一层,既将每一层下的layer.tar文件发送到clair服务端    

    err = analyzeLayer(endpoint, tmpPath+"/"+layerIDs[i]+"/layer.tar", layerIDs[i], layerIDs[i-1])    

    

    ......    

}    

func AnalyzeLocalImage(imageName string, minSeverity database.Severity, endpoint, myAddress, tmpPath string) error {  

  

    ......  

  

    //获取漏洞信息  

    layer, err := getLayer(endpoint, layerIDs[len(layerIDs)-1])  

    //打印漏洞报告  

    ......  

    for _, feature := range layer.Features {  

        if len(feature.Vulnerabilities) > 0 {  

            for _, vulnerability := range feature.Vulnerabilities {  

                severity := database.Severity(vulnerability.Severity)  

                isSafe = false  

  

                if minSeverity.Compare(severity) > 0 {  

                    continue  

                }  

  

                hasVisibleVulnerabilities = true  

                vulnerabilities = append(vulnerabilities, vulnerabilityInfo{vulnerability, feature, severity})  

            }  

        }  

    }  

    //排序输出报告美化  

    .....  

  

}  

至此,对analyze-local-images的源码已经分析完毕。从中可以可以看出。analyze-local-images做的事情很简单。

就是将layer.tar发送给clair。并将clair分析后的结果通过API接口获取到并在本地打印。

Clair源码剖析

analyze-local-images 发送layer.tar文件后主要是由/worker.go下的ProcessLayer方法进行处理的。

这里先简单讲下clair的目录结构,我们仅需要重点关注有注释的文件夹。

|–api  //api接口

|– cmd//服务端主程序

|–contrib

|–database //数据库相关

|–Documentation

|–ext  //拓展功能

|– pkg//通用方法

|– testdata

`–vendor

为了能够深入理解Clair,我们还是要从其main函数开始分析。

/cmd/clair/main.go

funcmain() {
   // 解析命令行参数,默认从/etc/clair/config.yaml读取数据库配置信息

   ......
   // 加载配置文件
   config, err :=LoadConfig(*flagConfigPath)
   if err != nil {
      log.WithError(err).Fatal("failedto load configuration")
   }

   // 初始化日志系统

......

//启动clair
   Boot(config)
}

 

/cmd/clair/main.go

 

funcBoot(config *Config) {
   ......
   // 打开数据库
   db, err :=database.Open(config.Database)
   if err != nil {
      log.Fatal(err)
   }
   defer db.Close()

   // 启动notifier服务
   st.Begin()
   go clair.RunNotifier(config.Notifier,db, st)

   // 启动clair的Rest API 服务
   st.Begin()
   go api.Run(config.API, db, st)
   st.Begin()

//启动clair的健康检测服务
   go api.RunHealth(config.API, db, st)

   // 启动updater服务
   st.Begin()
   go clair.RunUpdater(config.Updater,db, st)

   // Wait for interruption and shutdowngracefully.
   waitForSignals(syscall.SIGINT,syscall.SIGTERM)
   log.Info("Received interruption,gracefully stopping ...")
   st.Stop()
}

Go api.Run执行后,clair会开启Rest服务。

/api/api.go

func Run(cfg *Config, store database.Datastore, st *stopper.Stopper) {
   defer st.End()

   // 如果配置为空就不启动服务
   ......
   srv := &graceful.Server{
      Timeout:          0,    // Already handled by our TimeOut middleware
      NoSignalHandling: true, // We want to use our own Stopper
      Server: &http.Server{
         Addr:      ":" + strconv.Itoa(cfg.Port),
         TLSConfig: tlsConfig,
         Handler:   http.TimeoutHandler(newAPIHandler(cfg, store), cfg.Timeout, timeoutResponse),
      },
   }

//启动HTTP服务   
listenAndServeWithStopper(srv, st, cfg.CertFile, cfg.KeyFile)

   log.Info("main API stopped")
}

Api.Run中调用api.newAPIHandler生成一个API Handler来处理所有的API请求。

/api/router.go

funcnewAPIHandler(cfg *Config, store database.Datastore) http.Handler {
   router := make(router)
   router["/v1"] =v1.NewRouter(store, cfg.PaginationKey)
   return router
}

所有的router对应的Handler都在

/api/v1/router.go中:

 funcNewRouter(store database.Datastore, paginationKey string) *httprouter.Router {
   router := httprouter.New()
   ctx := &context{store,paginationKey}

   // Layers
   router.POST("/layers",httpHandler(postLayer, ctx))
  router.GET("/layers/:layerName", httpHandler(getLayer, ctx))
  router.DELETE("/layers/:layerName", httpHandler(deleteLayer,ctx))

   // Namespaces
   router.GET("/namespaces",httpHandler(getNamespaces, ctx))

   // Vulnerabilities
  router.GET("/namespaces/:namespaceName/vulnerabilities",httpHandler(getVulnerabilities, ctx))
   router.POST("/namespaces/:namespaceName/vulnerabilities",httpHandler(postVulnerability, ctx))
  router.GET("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName",httpHandler(getVulnerability, ctx))
  router.PUT("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName",httpHandler(putVulnerability, ctx))
  router.DELETE("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName",httpHandler(deleteVulnerability, ctx))

   // Fixes
  router.GET("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName/fixes",httpHandler(getFixes, ctx))
  router.PUT("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName/fixes/:fixName",httpHandler(putFix, ctx))
  router.DELETE("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName/fixes/:fixName",httpHandler(deleteFix, ctx))

   // Notifications
  router.GET("/notifications/:notificationName",httpHandler(getNotification, ctx))
  router.DELETE("/notifications/:notificationName",httpHandler(deleteNotification, ctx))

   // Metrics
   router.GET("/metrics",httpHandler(getMetrics, ctx))

   return router
}

而具体的Handler是在/api/v1/routers.go中

例如analyze-local-images 发送的layer.tar文件,最终会交给postLayer方法处理。

funcpostLayer(w http.ResponseWriter, r *http.Request, p httprouter.Params, ctx*context) (string, int) {
  ......
   err = clair.ProcessLayer(ctx.Store,request.Layer.Format, request.Layer.Name, request.Layer.ParentName,request.Layer.Path, request.Layer.Headers)
   ......
}

而ProcessLayer 方法就是在/worker.go中定义的。

funcProcessLayer(datastore database.Datastore, imageFormat, name, parentName, pathstring, headers map[string]string) error {
  //参数验证

......
   // 检测层是否已经入库

  layer, err := datastore.FindLayer(name, false, false)
   if err != nil && err !=commonerr.ErrNotFound {
      return err
   }


//如果存在并且该layer的Engine Version比DB中记录的大于等于3(目前最大的worker version),则表明已经detect过这个layer,则结束返回。否则detectContent对数据进行解析。
  
   // Analyze the content.
   layer.Namespace, layer.Features, err =detectContent(imageFormat, name, path, headers, layer.Parent)
   if err != nil {
      return err
   }

   return datastore.InsertLayer(layer)
}

在detectContent方法如下:

func detectContent(imageFormat,name, path string, headers map[string]string, parent *database.Layer)(namespace *database.Namespace, featureVersions []database.FeatureVersion, errerror) {
  ......

//解析namespace
   namespace, err = detectNamespace(name,files, parent)
   if err != nil {
      return
   }

   //解析特征版本

  featureVersions, err = detectFeatureVersions(name, files, namespace,parent)
   if err != nil {
      return
   }
  ......

return
}

Docker镜像静态扫描器的简易实现

通过刚才的源码分析,结合analyze-local-images以及clair。我们可以先实现一个简易的Docker静态分析器。对docker镜像逐层分析,实现输出软件特征版本。以便于我们了解clair的工作原理。

这里直接给出github链接:

https://github.com/MXi4oyu/DockerXScan/releases/tag/0.1

感兴趣的朋友可以自行下载测试。

这里给出Docker镜像静态扫描器的简易架构。

last.jpg

Docker镜像深度分析

(1)Webshell检测

对于webshell检测,我们可以采用三种方式。

方式一:模糊hash

模糊hash算法使用的是:https://ssdeep-project.github.io

我们根据其API实现了Go语言的绑定:gossdeep

主要API函数有两个,一个是Fuzzy_hash_file,一个是Fuzzy_compare。

1.提取文件模糊hash

Fuzzy_hash_file(“/var/www/shell.php”)

2.比较模糊hash

Fuzzy_compare(“3:YD6xL4fYvn:Y2xMwvn”,”3:YD6xL4fYvn:Y2xMwvk”)

方式二:yara规则引擎

根据yara规则库进行检测

Yara(“./libs/php.yar”,”/var/www/”)

方式三:机器学习

机器学习,分类算法:CNN-Text-Classfication

https://github.com/dennybritz/cnn-text-classification-tf/

(2)木马病毒检测

我们知道开源杀毒引擎ClamAV的病毒库非常强大,主要有

 1) 已知的恶意二进制文件的MD5哈希值

 2) PE(Windows 中可执行文件格式)节的MD5哈希值

 3) 十六进制特征码(shellcode)

 4) 存档元数据特征码

 5) 已知的合法文件的白名单数据库

我们可以将clamav的病毒库转换为yara规则,进行恶意代码识别。也可以利用开源的yara规则,进行木马病毒的检测。

(3)镜像历史分析

(4)动态扫描

通过docker的配置文件,我们可以获取到其暴漏出来的端口。模拟运行后,可以用常规的黑客漏洞扫描进行扫描。

(5)调用监控

利用Docker API检测文件与系统调用

这里先给出一些深度分析的思路,限于篇幅,我们会在以后的文章中做详细介绍。


前期文章

《docker容器的全面安全防护》

《配置一个安全的docker宿主机》

《利用docker插件实现细粒度权限控制》

后续预告

《docker最佳安全实践详解》

《docker内容信任详解》

《docker安全管理平台的架构设计》

 欢迎订阅关注我们!!!

2

取消
Loading...
css.php