Docker镜像扫描器的实现

Docker镜像简介

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

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

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

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

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

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

如何分析镜像

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

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

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

Clair整体架构如下：

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镜像。

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

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

}()

}

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

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)

}

}

}

//排序输出报告美化

.....

}

至此，对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

// 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镜像静态扫描器的简易架构。

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检测文件与系统调用

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