kubectl cp 命令安全漏洞分析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

$ kubectl cp --help
Copy files and directories to and from containers.

Examples:
  # !!!Important Note!!!
  # Requires that the 'tar' binary is present in your container
  # image.  If 'tar' is not present, 'kubectl cp' will fail.

  # Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod in the default namespace
  kubectl cp /tmp/foo_dir <some-pod>:/tmp/bar_dir

  # Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific container
  kubectl cp /tmp/foo <some-pod>:/tmp/bar -c <specific-container>

  # Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace <some-namespace>
  kubectl cp /tmp/foo <some-namespace>/<some-pod>:/tmp/bar

  # Copy /tmp/foo from a remote pod to /tmp/bar locally
  kubectl cp <some-namespace>/<some-pod>:/tmp/foo /tmp/bar

Options:
  -c, --container='': Container name. If omitted, the first container in the pod will be chosen
      --no-preserve=false: The copied file/directory's ownership and permissions will not be preserved in the container

Usage:
  kubectl cp <file-spec-src> <file-spec-dest> [options]

Use "kubectl options" for a list of global command-line options (applies to all commands).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func (o *CopyOptions) Run(args []string) error {
	// ...
	// Pod -> Pod: 如果源目标是一个 Pod 且目标源地址也是一个 Pod
	// 但是 kubectl cp 命令并不支持这一种情况，所以会先判断源目标是否是宿主机地址
	if len(srcSpec.PodName) != 0 && len(destSpec.PodName) != 0 {
		// 判断源目标是否是宿主机地址
		if _, err := os.Stat(args[0]); err == nil {
			// 执行 Host -> Pod 的逻辑
			return o.copyToPod(fileSpec{File: args[0]}, destSpec, &exec.ExecOptions{})
		}
		return fmt.Errorf("src doesn't exist in local filesystem")
	}

	// Pod -> Host: 如果源目标是 Pod 且目标源地址是宿主机地址
	if len(srcSpec.PodName) != 0 {
		return o.copyFromPod(srcSpec, destSpec)
	}

	// Host -> Pod: 如果源目标是宿主机地址且目标地址是 Pod
	if len(destSpec.PodName) != 0 {
		return o.copyToPod(srcSpec, destSpec, &exec.ExecOptions{})
	}
	// ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

func (o *CopyOptions) copyFromPod(src, dest fileSpec) error {
	// ...
	// 建立一个读写的 pipe
	// 从 reader 端进行读操作，从 outStream 端进行写操作
	reader, outStream := io.Pipe()

	// 构造 remote exec 的参数
	options := &exec.ExecOptions{
		StreamOptions: exec.StreamOptions{
			IOStreams: genericclioptions.IOStreams{
				In: nil,
				// 输出
				Out:    outStream,
				ErrOut: o.Out,
			},
			// 对应 Pod 的 Namespace
			Namespace: src.PodNamespace,
			// 对应 Pod 的名称
			PodName: src.PodName,
		},

		// 使用 tar 命令将 Pod 中的目标文件打包成一个二进制文件
		// 然后通过 outStream 进行传送
		// src.File 可以是一个目录，此时就是将一个目录的文件打包成一个 tar 文件
		Command:  []string{"tar", "cf", "-", src.File},
		Executor: &exec.DefaultRemoteExecutor{},
	}

	// 启动一个 goroutine 来执行远程 Pod 的 tar 命令
	go func() {
		defer outStream.Close()
		o.execute(options)
	}()

	// ...
	// 构造 prefix，后面将提及这一逻辑
	// ...
	return untarAll(reader, dest.File, prefix)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

func untarAll(reader io.Reader, destFile, prefix string) error {
	// ...
	tarReader := tar.NewReader(reader)
	// 遍历 tar 中的每一个文件
	// 如果文件是一个目录，在宿主机目标位置创建目录
	// 如果文件是一个普通文件，从 tar 中拷贝内容并在宿主机目标位置创建对应文件
	for {
		header, err := tarReader.Next()
		if err != nil {
			if err != io.EOF {
				return err
			}
			break
		}
		entrySeq++
		mode := header.FileInfo().Mode()
		outFileName := path.Join(destFile, clean(header.Name[len(prefix):]))
		baseName := path.Dir(outFileName)
		if err := os.MkdirAll(baseName, 0755); err != nil {
			return err
		}
		// 如果是目录，创建完目录后直接 continue 遍历下一个文件
		if header.FileInfo().IsDir() {
			if err := os.MkdirAll(outFileName, 0755); err != nil {
				return err
			}
			continue
		}

		// 目录文件的处理流程
		if entrySeq == 0 && !header.FileInfo().IsDir() {
			exists, err := dirExists(outFileName)
			if err != nil {
				return err
			}
			if exists {
				outFileName = filepath.Join(outFileName, path.Base(clean(header.Name)))
			}
		}

		// 普通文件的处理流程
		if mode&os.ModeSymlink != 0 {
			// 创建符号链接
			err := os.Symlink(header.Linkname, outFileName)
			if err != nil {
				return err
			}
		} else {
			// 拷贝创建对应文件
			outFile, err := os.Create(outFileName)
			if err != nil {
				return err
			}
			defer outFile.Close()
			if _, err := io.Copy(outFile, tarReader); err != nil {
				return err
			}
			if err := outFile.Close(); err != nil {
				return err
			}
		}
	}
	// ...
}

1

$ kubectl cp /some/remote/dir /some/local/dir

1
2
3
4
5

func untarAll(reader io.Reader, destFile, prefix string) error {
	// ...
	outFileName := path.Join(destFile, clean(header.Name[len(prefix):]))
	// ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func untarAll(reader io.Reader, destFile, prefix string) error {
	// ...
	if mode&os.ModeSymlink != 0 {
		linkname := header.Linkname
		// 判断这个符号链接是否在目标地址之外，如果是则忽略，不予创建
		relative, err := filepath.Rel(destFile, linkname)
		if path.IsAbs(linkname) &&
			(err != nil || relative != stripPathShortcuts(relative)) {
			// ...
			continue
		}
		if err := os.Symlink(linkname, outFileName); err != nil {
			return err
		}
		// ...
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func untarAll(reader io.Reader, destFile, prefix string) error {
	// ...
	if mode&os.ModeSymlink != 0 {
		// ...
		// 这个分支其实只判断了 linkname 是绝对路径的情况而忽略了相对路径的情况
		if path.IsAbs(linkname) &&
			(err != nil || relative != stripPathShortcuts(relative)) {
			...
			continue
		}
		// ...
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// linkJoin() 会考虑 link 是相对路径的场景
func linkJoin(base, link string) string {
	if filepath.IsAbs(link) {
		return link
	}
	return filepath.Join(base, link)
}

// 判断 dest 是否处于 base 之中
func isDestRelative(base, dest string) bool {
	fullPath := dest
	if !filepath.IsAbs(dest) {
		fullPath = filepath.Join(base, dest)
	}
	relative, err := filepath.Rel(base, fullPath)
	if err != nil {
		return false
	}
	return relative == "." || relative == stripPathShortcuts(relative)
}

func untarAll(reader io.Reader, destFile, prefix string) error {
	// ...
	if mode&os.ModeSymlink != 0 {
		linkname := header.Linkname
		if !isDestRelative(destDir, linkJoin(destFileName, linkname)) {
			// ...
			continue
		}
		// ...
	}
	// ...
}