Docker镜像简介
Docker镜像是由文件系统叠加而成。最底层是bootfs，之上的部分为rootfs。
bootfs是docker镜像最底层的引导文件系统，包含bootloader和操作系统内核。
rootfs通常包含一个操作系统运行所需的文件系统。这一层作为基础镜像。
在基础镜像之上，会加入各种镜像，如emacs、apache等。
Linux中的文件系统有些功能设计的很巧妙，比如挂载(mount)，允许把一个外部的文件系统（如CD，USB）以本地路径的形式去访问。例如放置一张CD后，我们可以通过访问/mnt/cdrom来查看CD中的内容。
Union File System（UnionFS）则设计的更加巧妙。在「挂载」功能的基础上，UnionFS允许在本地路径挂载多个目标目录。
UnionFS技术在Docker容器技术中的运用，首先体现在「镜像（image）」和「容器（container）」上。每一个Docker镜像都是一个只读的文件夹，当在容器中运行镜像时，Docker会自动挂载镜像中的、只读的文件目录，以及宿主机上一个临时的、可写的文件目录。容器中所有文件修改，都会写入这个临时目录里去。容器终结后，这个临时目录也会被相应删除。
UnionFS在Docker中的另一个应用，还体现在镜像本身上。容器运行时，在挂载的临时目录中如果写入数据，还可以选择把这部分数据从临时目录中保存下来，这样就生成了一个新的镜像。Docker在保存新镜像时，会把它们两部分——原镜像和增量——都保存在新镜像中。其中新的增量部分，就被称为「层（layer）」。
docker镜像保存
docker镜像是是分层存储的， 存储器包括aufs和overlay，overlay2等，默认存储在根路径/var/lib/docker下。
使用docker image insepect ubuntu，查看ubuntu镜像的layer地址
1 | "GraphDriver": { |
2 | "Name": "overlay2", |
3 | "Data": { |
4 | "LowerDir": "/var/lib/docker/overlay2/dae8b41387884954d897fdab0aace674b1ccf29d7122d2b4aaa72f1874ac4b8b/diff:/var/lib/docker/overlay2/f5ae89ddaae69a185e5b352dbf5a18390f3f2024492db3d0e981892c767b919f/diff:/var/lib/docker/overlay2/c59b417d51fc4a6e590391d59a5a273b44d1c9c1a45d02806591dc735ee785e5/diff", |
5 | "MergedDir": "/var/lib/docker/overlay2/8a801c1be8981cb28da1083b255216027fc68449efe36cc39f7d7ea8cbb96e98/merged", |
6 | "UpperDir": "/var/lib/docker/overlay2/8a801c1be8981cb28da1083b255216027fc68449efe36cc39f7d7ea8cbb96e98/diff", |
7 | "WorkDir": "/var/lib/docker/overlay2/8a801c1be8981cb28da1083b255216027fc68449efe36cc39f7d7ea8cbb96e98/work" |
8 | } |
9 | }, |
LowerDir 是包含image的只读层，表示更改的读写层是 UpperDir的一部分。MergedDir表示Docker用于运行容器的UpperDir和LowerDir的结果。WorkDir是overlay2的内部目录，应该为空。
clair扫描原理
Clair首先对镜像进行特征的提取，然后再将这些特征匹配CVE漏洞库，若发现漏洞则进行提示，其功能侧重于扫描容器中的OS及APP的CVE漏洞。该工具可以交叉检查Docker镜像的操作系统以及上面安装的任何包是否与任何已知不安全的包版本相匹配，支持跟K8S、Registry结合在一起，在镜像构建过程进行漏洞扫描，支持OS广泛，提供API，能提供构建阻断和报警。
在开始分析Clair之前，我们需要明白几点：
- Clair是以静态分析的方式对镜像进行分析的，有点类似于杀毒软件用特征码来扫描病毒。
- Clair镜像分析是按镜像Layer层级来进行的，如果某一层的软件有漏洞，在上层被删除了，该漏洞还是存在的。
- Clair的漏洞扫描是通过软件版本比对来完成的，如果某个应用，比如Nginx ，它在镜像中的版本为1.0.0，而该版本在数据库中存在1.0.0对应的漏洞数据，则表示该镜像存在对应的漏洞。
架构：
整体处理流程如下：
- Clair定期从配置的源获取漏洞元数据然后存进数据库。
- 客户端使用Clair API处理镜像，获取镜像的特征并存进数据库。
- 客户端使用Clair API从数据库查询特定镜像的漏洞情况，为每个请求关联漏洞和特征，避免需要重新扫描镜像。
- 当更新漏洞元数据时，将会有系统通知产生。另外，还有WebHook用于配置将受影响的镜像记录起来或者拦截其部署。
客户端扫描
客户端 analyze-local-images ，执行流程
main()->intMain()->AnalyzeLocalImage()—>analyzeLayer()->getLayer()
1） 在tmp文件夹新建临时文件夹
1 | tmpPath, err := ioutil.TempDir("", "analyze-local-image-") |
2 | if err != nil { |
3 | log.Fatalf("Could not create temporary folder: %s", err) |
4 | } |
5 | defer os.RemoveAll(tmpPath) |
6 | |
7 | // Intercept SIGINT / SIGKILl signals. |
8 | interrupt := make(chan os.Signal) |
9 | signal.Notify(interrupt, os.Interrupt, os.Kill) |
10 | |
11 | // Analyze the image. |
12 | analyzeCh := make(chan error, 1) |
13 | go func() { |
14 | analyzeCh <- AnalyzeLocalImage(imageName, minSeverity, *flagEndpoint, *flagMyAddress, tmpPath) |
15 | }() |
2） 跟进AnalyzeLocalImage函数
1 | func AnalyzeLocalImage(imageName string, minSeverity database.Severity, endpoint, myAddress, tmpPath string) error { |
2 | // Save image. |
3 | log.Printf("Saving %s to local disk (this may take some time)", imageName) |
4 | err := save(imageName, tmpPath) |
5 | if err != nil { |
6 | return fmt.Errorf("Could not save image: %s", err) |
7 | } |
8 | |
9 | // Retrieve history. |
10 | log.Println("Retrieving image history") |
11 | layerIDs, err := historyFromManifest(tmpPath) |
12 | if err != nil { |
13 | layerIDs, err = historyFromCommand(imageName) |
14 | } |
15 | if err != nil || len(layerIDs) == 0 { |
16 | return fmt.Errorf("Could not get image's history: %s", err) |
17 | } |
跟进save函数，使用docker save保存镜像，并解压到上面建的tmp文件夹下
1 | func save(imageName, path string) error { |
2 | var stderr bytes.Buffer |
3 | save := exec.Command("docker", "save", imageName) |
4 | save.Stderr = &stderr |
5 | extract := exec.Command("tar", "xf", "-", "-C"+path) |
6 | extract.Stderr = &stderr |
7 | pipe, err := extract.StdinPipe() |
8 | if err != nil { |
9 | return err |
10 | } |
跟进historyFromMainfest函数，分析manifest.json，获取镜像的layer信息
1 | func historyFromManifest(path string) ([]string, error) { |
2 | mf, err := os.Open(path + "/manifest.json") |
3 | if err != nil { |
4 | return nil, err |
5 | } |
6 | defer mf.Close() |
7 | |
8 | // https://github.com/docker/docker/blob/master/image/tarexport/tarexport.go#L17 |
9 | type manifestItem struct { |
10 | Config string |
11 | RepoTags []string |
12 | Layers []string |
13 | } |
14 | |
15 | var manifest []manifestItem |
16 | if err = json.NewDecoder(mf).Decode(&manifest); err != nil { |
17 | return nil, err |
18 | } else if len(manifest) != 1 { |
19 | return nil, err |
20 | } |
21 | var layers []string |
22 | for _, layer := range manifest[0].Layers { |
23 | layers = append(layers, strings.TrimSuffix(layer, "/layer.tar")) |
24 | } |
25 | return layers, nil |
26 | } |
3）跟进分析analyzeLayer和getLayer函数，分别是发送请求到服务端和从服务端获取漏洞信息结果
1 | func analyzeLayer(endpoint, path, layerName, parentLayerName string) error { |
2 | payload := v1.LayerEnvelope{ |
3 | Layer: &v1.Layer{ |
4 | Name: layerName, |
5 | Path: path, |
6 | ParentName: parentLayerName, |
7 | Format: "Docker", |
8 | }, |
9 | } |
10 | |
11 | jsonPayload, err := json.Marshal(payload) |
12 | if err != nil { |
13 | return err |
14 | } |
15 | |
16 | request, err := http.NewRequest("POST", endpoint+postLayerURI, bytes.NewBuffer(jsonPayload)) |
17 | if err != nil { |
18 | return err |
19 | } |
20 | request.Header.Set("Content-Type", "application/json") |
21 | |
22 | client := &http.Client{} |
23 | response, err := client.Do(request) |
24 | if err != nil { |
25 | return err |
26 | } |
27 | defer response.Body.Close() |
28 | |
29 | if response.StatusCode != 201 { |
30 | body, _ := ioutil.ReadAll(response.Body) |
31 | return fmt.Errorf("Got response %d with message %s", response.StatusCode, string(body)) |
32 | } |
33 | |
34 | return nil |
35 | } |
36 | |
37 | func getLayer(endpoint, layerID string) (v1.Layer, error) { |
38 | response, err := http.Get(endpoint + fmt.Sprintf(getLayerFeaturesURI, layerID)) |
39 | if err != nil { |
40 | return v1.Layer{}, err |
41 | } |
42 | defer response.Body.Close() |
43 | |
44 | if response.StatusCode != 200 { |
45 | body, _ := ioutil.ReadAll(response.Body) |
46 | err := fmt.Errorf("Got response %d with message %s", response.StatusCode, string(body)) |
47 | return v1.Layer{}, err |
48 | } |
49 | |
50 | var apiResponse v1.LayerEnvelope |
51 | if err = json.NewDecoder(response.Body).Decode(&apiResponse); err != nil { |
52 | return v1.Layer{}, err |
53 | } else if apiResponse.Error != nil { |
54 | return v1.Layer{}, errors.New(apiResponse.Error.Message) |
55 | } |
56 | |
57 | return *apiResponse.Layer, nil |
58 | } |
客户端做的事情很简单， 就是将layer.tar发送给clair，并将clair分析后的结果通过API接口获取到并在本地打印。
服务端扫描
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
1 | funcmain() { |
2 | // 解析命令行参数，默认从/etc/clair/config.yaml读取数据库配置信息 |
3 | |
4 | ...... |
5 | // 加载配置文件 |
6 | config, err :=LoadConfig(*flagConfigPath) |
7 | if err != nil { |
8 | log.WithError(err).Fatal("failedto load configuration") |
9 | } |
10 | |
11 | // 初始化日志系统 |
12 | |
13 | ...... |
14 | |
15 | //启动clair |
16 | Boot(config) |
17 | } |
18 | |
19 | |
20 | |
21 | # /cmd/clair/main.go |
22 | |
23 | funcBoot(config *Config) { |
24 | ...... |
25 | // 打开数据库 |
26 | db, err :=database.Open(config.Database) |
27 | if err != nil { |
28 | log.Fatal(err) |
29 | } |
30 | defer db.Close() |
31 | |
32 | // 启动notifier服务 |
33 | st.Begin() |
34 | go clair.RunNotifier(config.Notifier,db, st) |
35 | |
36 | // 启动clair的Rest API 服务 |
37 | st.Begin() |
38 | go api.Run(config.API, db, st) |
39 | st.Begin() |
40 | |
41 | //启动clair的健康检测服务 |
42 | go api.RunHealth(config.API, db, st) |
43 | |
44 | // 启动updater服务 |
45 | st.Begin() |
46 | go clair.RunUpdater(config.Updater,db, st) |
47 | |
48 | // Wait for interruption and shutdowngracefully. |
49 | waitForSignals(syscall.SIGINT,syscall.SIGTERM) |
50 | log.Info("Received interruption,gracefully stopping ...") |
51 | st.Stop() |
52 | } |
Go api.Run执行后，clair会开启Rest服务。
/api/api.go
1 | func Run(cfg *Config, store database.Datastore, st *stopper.Stopper) { |
2 | defer st.End() |
3 | |
4 | // 如果配置为空就不启动服务 |
5 | ...... |
6 | srv := &graceful.Server{ |
7 | Timeout: 0, // Already handled by our TimeOut middleware |
8 | NoSignalHandling: true, // We want to use our own Stopper |
9 | Server: &http.Server{ |
10 | Addr: ":" + strconv.Itoa(cfg.Port), |
11 | TLSConfig: tlsConfig, |
12 | Handler: http.TimeoutHandler(newAPIHandler(cfg, store), cfg.Timeout, timeoutResponse), |
13 | }, |
14 | } |
15 | |
16 | //启动HTTP服务 |
17 | listenAndServeWithStopper(srv, st, cfg.CertFile, cfg.KeyFile) |
18 | |
19 | log.Info("main API stopped") |
20 | } |
Api.Run中调用api.newAPIHandler生成一个API Handler来处理所有的API请求。
/api/router.go
1 | funcnewAPIHandler(cfg *Config, store database.Datastore) http.Handler { |
2 | router := make(router) |
3 | router["/v1"] =v1.NewRouter(store, cfg.PaginationKey) |
4 | return router |
5 | } |
所有的router对应的Handler都在
/api/v1/router.go中：
1 | funcNewRouter(store database.Datastore, paginationKey string) *httprouter.Router { |
2 | router := httprouter.New() |
3 | ctx := &context{store,paginationKey} |
4 | |
5 | // Layers |
6 | router.POST("/layers",httpHandler(postLayer, ctx)) |
7 | router.GET("/layers/:layerName", httpHandler(getLayer, ctx)) |
8 | router.DELETE("/layers/:layerName", httpHandler(deleteLayer,ctx)) |
9 | |
10 | // Namespaces |
11 | router.GET("/namespaces",httpHandler(getNamespaces, ctx)) |
12 | |
13 | // Vulnerabilities |
14 | router.GET("/namespaces/:namespaceName/vulnerabilities",httpHandler(getVulnerabilities, ctx)) |
15 | router.POST("/namespaces/:namespaceName/vulnerabilities",httpHandler(postVulnerability, ctx)) |
16 | router.GET("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName",httpHandler(getVulnerability, ctx)) |
17 | router.PUT("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName",httpHandler(putVulnerability, ctx)) |
18 | router.DELETE("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName",httpHandler(deleteVulnerability, ctx)) |
19 | |
20 | // Fixes |
21 | router.GET("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName/fixes",httpHandler(getFixes, ctx)) |
22 | router.PUT("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName/fixes/:fixName",httpHandler(putFix, ctx)) |
23 | router.DELETE("/namespaces/:namespaceName/vulnerabilities/:vulnerabilityName/fixes/:fixName",httpHandler(deleteFix, ctx)) |
24 | |
25 | // Notifications |
26 | router.GET("/notifications/:notificationName",httpHandler(getNotification, ctx)) |
27 | router.DELETE("/notifications/:notificationName",httpHandler(deleteNotification, ctx)) |
28 | |
29 | // Metrics |
30 | router.GET("/metrics",httpHandler(getMetrics, ctx)) |
31 | |
32 | return router |
33 | } |
而具体的Handler是在/api/v1/routers.go中
例如analyze-local-images 发送的layer.tar文件，最终会交给postLayer方法处理。
1 | funcpostLayer(w http.ResponseWriter, r *http.Request, p httprouter.Params, ctx*context) (string, int) { |
2 | ...... |
3 | err = clair.ProcessLayer(ctx.Store,request.Layer.Format, request.Layer.Name, request.Layer.ParentName,request.Layer.Path, request.Layer.Headers) |
4 | ...... |
5 | } |
而ProcessLayer 方法就是在/worker.go中定义的。
1 | funcProcessLayer(datastore database.Datastore, imageFormat, name, parentName, pathstring, headers map[string]string) error { |
2 | //参数验证 |
3 | |
4 | ...... |
5 | // 检测层是否已经入库 |
6 | |
7 | layer, err := datastore.FindLayer(name, false, false) |
8 | if err != nil && err !=commonerr.ErrNotFound { |
9 | return err |
10 | } |
11 | |
12 | |
13 | //如果存在并且该layer的Engine Version比DB中记录的大于等于3（目前最大的worker version）,则表明已经detect过这个layer，则结束返回。否则detectContent对数据进行解析。 |
14 | |
15 | // Analyze the content. |
16 | layer.Namespace, layer.Features, err =detectContent(imageFormat, name, path, headers, layer.Parent) |
17 | if err != nil { |
18 | return err |
19 | } |
20 | |
21 | return datastore.InsertLayer(layer) |
22 | } |
在detectContent方法如下：
1 | func detectContent(imageFormat,name, path string, headers map[string]string, parent *database.Layer)(namespace *database.Namespace, featureVersions []database.FeatureVersion, errerror) { |
2 | ...... |
3 | |
4 | //解析namespace |
5 | namespace, err = detectNamespace(name,files, parent) |
6 | if err != nil { |
7 | return |
8 | } |
9 | |
10 | //解析特征版本 |
11 | |
12 | featureVersions, err = detectFeatureVersions(name, files, namespace,parent) |
13 | if err != nil { |
14 | return |
15 | } |
16 | ...... |
17 | |
18 | return |
19 | } |
参考：
https://blog.csdn.net/weixin_39800144/article/details/79019503
https://cloud.tencent.com/developer/article/1039768
https://zhuanlan.zhihu.com/p/43372662
https://zhuanlan.zhihu.com/p/41958018
https://www.freebuf.com/column/157784.html
https://www.freecodecamp.org/news/where-are-docker-images-stored-docker-container-paths-explained/
