如何在 Golang 代碼里面解析容器鏡像

作者：阿里技術(shù) 2022-01-05 18:19:30

容器鏡像在我們?nèi)粘５拈_(kāi)發(fā)工作中占據(jù)著極其重要的位置。通常情況下我們是將應(yīng)用程序打包到容器鏡像并上傳到鏡像倉(cāng)庫(kù)中，在生產(chǎn)環(huán)境將其拉取下來(lái)。

一背景

容器鏡像在我們?nèi)粘５拈_(kāi)發(fā)工作中占據(jù)著極其重要的位置。通常情況下我們是將應(yīng)用程序打包到容器鏡像并上傳到鏡像倉(cāng)庫(kù)中，在生產(chǎn)環(huán)境將其拉取下來(lái)。然后用 docker/containerd 等容器運(yùn)行時(shí)將鏡像啟動(dòng)，開(kāi)始執(zhí)行應(yīng)用。但是對(duì)于一些運(yùn)維平臺(tái)來(lái)說(shuō)，對(duì)于一個(gè)鏡像制品本身的掃描和分析才是真正的關(guān)注點(diǎn)。本文簡(jiǎn)單介紹下如何在代碼中解析一個(gè)容器鏡像。

二 go-containerregistry

go-containerregistry 是 google 公司的一個(gè)開(kāi)源項(xiàng)目，它提供了一個(gè)對(duì)鏡像的操作接口，這個(gè)接口背后的資源可以是鏡像倉(cāng)庫(kù)的遠(yuǎn)程資源，鏡像的tar包，甚至是 docker daemon 進(jìn)程。下面我們就簡(jiǎn)單介紹下如何使用這個(gè)項(xiàng)目來(lái)完成我們的目標(biāo)—— 在代碼中解析鏡像。

除了對(duì)外提供了三方包，該項(xiàng)目里面還提供了 crane (與遠(yuǎn)端鏡像交互的客戶端)gcrane (與 gcr 交互的客戶端)。

三基本接口

1 鏡像基本概念

在介紹具體接口之間先介紹幾個(gè)簡(jiǎn)單概念

ImageIndex，根據(jù) OCI 規(guī)范，是為了兼容多架構(gòu)(amd64, arm64)鏡像而創(chuàng)造出來(lái)的數(shù)據(jù)結(jié)構(gòu), 我們可以在一個(gè)ImageIndex 里面關(guān)聯(lián)多個(gè)鏡像，使用同一個(gè)鏡像tag，客戶端(docker，ctr)會(huì)根據(jù)客戶端所在的操作系統(tǒng)的基礎(chǔ)架構(gòu)拉取對(duì)應(yīng)架構(gòu)的鏡像下來(lái)
Image Manifest 基本上對(duì)應(yīng)了一個(gè)鏡像，里面包含了一個(gè)鏡像的所有l(wèi)ayers digest，客戶端拉取鏡像的時(shí)候一般都是先獲取manifest 文件，在根據(jù) manifest 文件里面的內(nèi)容拉取鏡像各個(gè)層(tar+gzip)
Image Config 跟 ImageManifest 是一一對(duì)應(yīng)的關(guān)系，Image Config 主要包含一些鏡像的基本配置，例如創(chuàng)建時(shí)間，作者，該鏡像的基礎(chǔ)架構(gòu)，鏡像層的 diffID(未壓縮的 ChangeSet)，ChainID 之類的信息。一般在宿主機(jī)上執(zhí)行 docker image 看到的ImageID就是 ImageConfig 的hash值。
layer 就是鏡像層，鏡像層信息不包含任何的運(yùn)行時(shí)信息(環(huán)境變量等)只包含文件系統(tǒng)的信息。鏡像是通過(guò)最底層 rootfs 加上各層的 changeset(對(duì)上一層的 add, update, delete 操作)組合而成的。
- layer diffid 是未壓縮的層的hash值，常見(jiàn)于本地環(huán)境，使用看到的便是diffid。因?yàn)榭蛻舳艘话阆螺d ImageConfig, ImageConfig 里面是引用的diffid。
- layer digest 是壓縮后的層的hash值，常見(jiàn)于鏡像倉(cāng)庫(kù) 使用看到的layers 一般都是 digest. 因?yàn)?manifest 引用都是 layer digest。
- 兩者沒(méi)有可以直接轉(zhuǎn)換的方式，目前的唯一方式就是按照順序來(lái)對(duì)應(yīng)。
- 用一張圖來(lái)總結(jié)一下。

// ImageIndex 定義與 OCI ImageIndex 交互的接口 
type ImageIndex interface { 
  // 返回當(dāng)前 imageIndex 的 MediaType 
  MediaType() (types.MediaType, error) 
 
  // 返回這個(gè) ImageIndex manifest 的 sha256值。 
  Digest() (Hash, error) 
 
  // 返回這個(gè) ImageIndex manifest 的大小 
  Size() (int64, error) 
 
  // 返回這個(gè) ImageIndex 的 manifest 結(jié)構(gòu) 
  IndexManifest() (*IndexManifest, error) 
 
  // 返回這個(gè) ImageIndex 的 manifest 字節(jié)數(shù)組 
  RawManifest() ([]byte, error) 
 
  // 返回這個(gè) ImageIndex 引用的 Image 
  Image(Hash) (Image, error) 
 
  // 返回這個(gè) ImageIndex 引用的 ImageIndex 
  ImageIndex(Hash) (ImageIndex, error) 
} 
 
// Image  定義了與 OCI Image 交互的接口 
type Image interface { 
  // 返回了當(dāng)前鏡像的所有層級(jí)， 最老/最基礎(chǔ)的層在數(shù)組的前面，最上面/最新的層在數(shù)組的后面 
  Layers() ([]Layer, error) 
 
  // 返回當(dāng)前 image 的 MediaType 
  MediaType() (types.MediaType, error) 
 
  // 返回這個(gè) Image manifest 的大小 
  Size() (int64, error) 
 
  // 返回這個(gè)鏡像 ConfigFile 的hash值，也是這個(gè)鏡像的 ImageID 
  ConfigName() (Hash, error) 
 
  // 返回這個(gè)鏡像的 ConfigFile 
  ConfigFile() (*ConfigFile, error) 
 
  // 返回這個(gè)鏡像的 ConfigFile 的字節(jié)數(shù)組 
  RawConfigFile() ([]byte, error) 
 
  // 返回這個(gè)Image Manifest 的sha256 值 
  Digest() (Hash, error) 
 
  // 返回這個(gè)Image Manifest 
  Manifest() (*Manifest, error) 
 
  // 返回 ImageManifest 的bytes數(shù)組 
  RawManifest() ([]byte, error) 
 
  // 返回這個(gè)鏡像中的某一層layer， 根據(jù) digest（壓縮后的hash值） 來(lái)查找 
  LayerByDigest(Hash) (Layer, error) 
 
  // 返回這個(gè)鏡像中的某一層layer， 根據(jù) diffid （未壓縮的hash值） 來(lái)查找 
  LayerByDiffID(Hash) (Layer, error) 
} 
 
// Layer 定義了訪問(wèn) OCI Image 特定 Layer 的接口 
type Layer interface { 
  // 返回了壓縮后的layer的sha256 值 
  Digest() (Hash, error) 
 
  // 返回了 未壓縮的layer 的sha256值. 
  DiffID() (Hash, error) 
 
  // 返回了壓縮后的鏡像層 
  Compressed() (io.ReadCloser, error) 
 
  // 返回了未壓縮的鏡像層 
  Uncompressed() (io.ReadCloser, error) 
 
  // 返回了壓縮后鏡像層的大小 
  Size() (int64, error) 
 
  // 返回當(dāng)前 layer 的 MediaType 
  MediaType() (types.MediaType, error) 
}

相關(guān)接口功能已在注釋中說(shuō)明，不再贅述。

四獲取鏡像相關(guān)元信息

我們以 remote 方式(拉取遠(yuǎn)程鏡像) 舉例說(shuō)明下如何使用。

package main 
 
import ( 
  "github.com/google/go-containerregistry/pkg/authn" 
  "github.com/google/go-containerregistry/pkg/name" 
  "github.com/google/go-containerregistry/pkg/v1/remote" 
) 
 
func main() { 
  ref, err := name.ParseReference("xxx") 
  if err != nil { 
    panic(err) 
  } 
  tryRemote(context.TODO(), ref, GetDockerOption()) 
  if err != nil { 
    panic(err) 
  } 
 
  // do stuff with img 
} 
 
type DockerOption struct { 
  // Auth 
  UserName string 
  Password string 
 
  // RegistryToken is a bearer token to be sent to a registry 
  RegistryToken string 
 
  // ECR 
  AwsAccessKey    string 
  AwsSecretKey    string 
  AwsSessionToken string 
  AwsRegion       string 
 
  // GCP 
  GcpCredPath string 
 
  InsecureSkipTLSVerify bool 
  NonSSL                bool 
  SkipPing              bool // this is ignored now 
  Timeout               time.Duration 
} 
 
func GetDockerOption() (types.DockerOption, error) { 
  cfg := DockerConfig{} 
  if err := env.Parse(&cfg); err != nil { 
    return types.DockerOption{}, fmt.Errorf("unable to parse environment variables: %w", err) 
  } 
 
  return types.DockerOption{ 
    UserName:              cfg.UserName, 
    Password:              cfg.Password, 
    RegistryToken:         cfg.RegistryToken, 
    InsecureSkipTLSVerify: cfg.Insecure, 
    NonSSL:                cfg.NonSSL, 
  }, nil 
} 
 
func tryRemote(ctx context.Context, ref name.Reference, option types.DockerOption) (v1.Image, extender, error) { 
  var remoteOpts []remote.Option 
  if option.InsecureSkipTLSVerify { 
    t := &http.Transport{ 
      TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, 
    } 
    remoteOpts = append(remoteOpts, remote.WithTransport(t)) 
  } 
 
  domain := ref.Context().RegistryStr() 
  auth := token.GetToken(ctx, domain, option) 
 
  if auth.Username != "" && auth.Password != "" { 
    remoteOpts = append(remoteOpts, remote.WithAuth(&auth)) 
  } else if option.RegistryToken != "" { 
    bearer := authn.Bearer{Token: option.RegistryToken} 
    remoteOpts = append(remoteOpts, remote.WithAuth(&bearer)) 
  } else { 
    remoteOpts = append(remoteOpts, remote.WithAuthFromKeychain(authn.DefaultKeychain)) 
  } 
 
  desc, err := remote.Get(ref, remoteOpts...) 
  if err != nil { 
    return nil, nil, err 
  } 
 
  img, err := desc.Image() 
  if err != nil { 
    return nil, nil, err 
  } 
 
  // Return v1.Image if the image is found in Docker Registry 
  return img, remoteExtender{ 
    ref:        implicitReference{ref: ref}, 
    descriptor: desc, 
  }, nil 
}

執(zhí)行完 tryRemote 代碼之后就可以獲取 Image 對(duì)象的實(shí)例，進(jìn)而對(duì)這個(gè)實(shí)例進(jìn)行操作。明確以下幾個(gè)關(guān)鍵點(diǎn)

remote.Get() 方法只會(huì)實(shí)際拉取鏡像的manifestList/manifest，并不會(huì)拉取整個(gè)鏡像。
desc.Image() 方法會(huì)判斷 remote.Get() 返回的媒體類型。如果是鏡像的話直接返回一個(gè) Image interface, 如果是 manifest list 的情況會(huì)解析當(dāng)前宿主機(jī)的架構(gòu)，并且返回指定架構(gòu)對(duì)應(yīng)的鏡像。同樣這里并不會(huì)拉取鏡像。
所有的數(shù)據(jù)都是lazy load。只有需要的時(shí)候才會(huì)去獲取。

五讀取鏡像中系統(tǒng)軟件的信息

通過(guò)上面的接口定義可知，我們可以通過(guò) Image.LayerByDiffID(Hash) (Layer, error) 獲取一個(gè) layer 對(duì)象，獲取了layer對(duì)象之后我們可以調(diào)用 layer.Uncompressed() 方法獲取一個(gè)未被壓縮的層的 io.Reader , 也就是一個(gè) tar file。

// tarOnceOpener 讀取文件一次并共享內(nèi)容，以便分析器可以共享數(shù)據(jù) 
func tarOnceOpener(r io.Reader) func() ([]byte, error) { 
  var once sync.Once 
  var b []byte 
  var err error 
 
  return func() ([]byte, error) { 
    once.Do(func() { 
      b, err = ioutil.ReadAll(r) 
    }) 
    if err != nil { 
      return nil, xerrors.Errorf("unable to read tar file: %w", err) 
    } 
    return b, nil 
  } 
} 
 
// 該方法主要是遍歷整個(gè) io stream，首先解析出文件的元信息 （path, prefix,suffix）, 然后調(diào)用 analyzeFn 方法解析文件內(nèi)容 
func WalkLayerTar(layer io.Reader, analyzeFn WalkFunc) ([]string, []string, error) { 
  var opqDirs, whFiles []string 
  var result *AnalysisResult 
  tr := tar.NewReader(layer) 
  opq := ".wh..wh..opq" 
  wh  := ".wh." 
  for { 
    hdr, err := tr.Next() 
    if err == io.EOF { 
      break 
    } 
    if err != nil { 
      return nil, nil, xerrors.Errorf("failed to extract the archive: %w", err) 
    } 
 
    filePath := hdr.Name 
    filePath = strings.TrimLeft(filepath.Clean(filePath), "/") 
    fileDir, fileName := filepath.Split(filePath) 
 
    // e.g. etc/.wh..wh..opq 
    if opq == fileName { 
      opqDirs = append(opqDirs, fileDir) 
      continue 
    } 
    // etc/.wh.hostname 
    if strings.HasPrefix(fileName, wh) { 
      name := strings.TrimPrefix(fileName, wh) 
      fpath := filepath.Join(fileDir, name) 
      whFiles = append(whFiles, fpath) 
      continue 
    } 
 
    if hdr.Typeflag == tar.TypeSymlink || hdr.Typeflag == tar.TypeLink || hdr.Typeflag == tar.TypeReg { 
      analyzeFn(filePath, hdr.FileInfo(), tarOnceOpener(tr), result) 
      if err != nil { 
        return nil, nil, xerrors.Errorf("failed to analyze file: %w", err) 
      } 
    } 
  } 
 
  return opqDirs, whFiles, nil 
} 
 
// 調(diào)用不同的driver 對(duì)同一個(gè)文件進(jìn)行解析 
func analyzeFn(filePath string, info os.FileInfo, opener analyzer.Opener,result *AnalysisResult) error { 
    if info.IsDir() { 
        return nil, nil 
    } 
     
    var wg sync.WaitGroup 
    for _, d := range drivers { 
      // filepath extracted from tar file doesn't have the prefix "/" 
      if !d.Required(strings.TrimLeft(filePath, "/"), info) { 
        continue 
      } 
      b, err := opener() 
      if err != nil { 
        return nil, xerrors.Errorf("unable to open a file (%s): %w", filePath, err) 
      } 
 
      if err = limit.Acquire(ctx, 1); err != nil { 
        return nil, xerrors.Errorf("semaphore acquire: %w", err) 
      } 
      wg.Add(1) 
 
      go func(a analyzer, target AnalysisTarget) { 
        defer limit.Release(1) 
        defer wg.Done() 
 
        ret, err := a.Analyze(target) 
        if err != nil && !xerrors.Is(err, aos.AnalyzeOSError) { 
          log.Logger.Debugf("Analysis error: %s", err) 
          return nil, err 
        } 
        result.Merge(ret) 
      }(d, AnalysisTarget{Dir: dir, FilePath: filePath, Content: b}) 
    } 
     
     
    return result, nil 
} 
 
// drivers: 用于解析tar包中的文件 
func (a alpinePkgAnalyzer) Analyze(target analyzer.AnalysisTarget) (*analyzer.AnalysisResult, error) { 
  scanner := bufio.NewScanner(bytes.NewBuffer(target.Content)) 
  var pkg types.Package 
  var version string 
  for scanner.Scan() { 
    line := scanner.Text() 
 
    // check package if paragraph end 
    if len(line) < 2 { 
      if analyzer.CheckPackage(&pkg) { 
        pkgs = append(pkgs, pkg) 
      } 
      pkg = types.Package{} 
      continue 
    } 
 
    switch line[:2] { 
    case "P:": 
      pkg.Name = line[2:] 
    case "V:": 
      version = string(line[2:]) 
      if !apkVersion.Valid(version) { 
        log.Printf("Invalid Version Found : OS %s, Package %s, Version %s", "alpine", pkg.Name, version) 
        continue 
      } 
      pkg.Version = version 
    case "o:": 
      origin := line[2:] 
      pkg.SrcName = origin 
      pkg.SrcVersion = version 
    } 
  } 
  // in case of last paragraph 
  if analyzer.CheckPackage(&pkg) { 
    pkgs = append(pkgs, pkg) 
  } 
 
  parsedPkgs := a.uniquePkgs(pkgs) 
 
  return &analyzer.AnalysisResult{ 
    PackageInfos: []types.PackageInfo{ 
      { 
        FilePath: target.FilePath, 
        Packages: parsedPkgs, 
      }, 
    }, 
  }, nil 
}

以上代碼的重點(diǎn)在于 Analyze(target analyzer.AnalysisTarget) 方法，在介紹這個(gè)方法之前，有兩個(gè)特殊文件需要稍微介紹下。眾所周知，鏡像是分層的，并且所有層都是只讀的。當(dāng)容器是以鏡像為基礎(chǔ)起來(lái)的時(shí)候，它會(huì)將所有鏡像層包含的文件組合成為 rootfs 對(duì)容器暫時(shí)，當(dāng)我們將容器 commit 成一個(gè)新的鏡像的時(shí)候，容器內(nèi)對(duì)文件修改會(huì)以新的layer 的方式覆蓋到原有的鏡像中。其中有如下兩種特殊文件：

.wh..wh..opq: 代表這個(gè)文件所在的目錄被刪除了
.wh.：以這個(gè)詞綴開(kāi)頭的文件說(shuō)明這個(gè)文件在當(dāng)前層已經(jīng)被刪除

所以綜上所述，所有容器內(nèi)的文件刪除均不是真正的刪除。所以我們?cè)?WalkLayerTar 方法中將兩個(gè)文件記錄下來(lái)，跳過(guò)解析。

1 Analyze(target analyzer.AnalysisTarget)

首先我們調(diào)用 bufio.scanner.Scan() 方法，他會(huì)不斷掃描文件中的信息，當(dāng)返回false 的時(shí)候代表掃描到文件結(jié)尾，如果這時(shí)在掃描過(guò)程中沒(méi)有錯(cuò)誤，則 scanner 的 Err 字段為 nil
我們通過(guò) scanner.Text() 獲取掃描文件的每一行，截取每一行的前兩個(gè)字符，得出 apk package 的 package name & package version。

六讀取鏡像中的java 應(yīng)用信息

下面我們實(shí)際來(lái)看下如何讀取java 應(yīng)用中的依賴信息，包括應(yīng)用依賴 & jar包依賴，首先我們使用上面的方式讀取某一層的文件信息。

如果發(fā)現(xiàn) 文件是jar包
初始化 zip reader，開(kāi)始讀取 jar 包內(nèi)容
開(kāi)始通過(guò) jar包名稱進(jìn)行解析 artifact的名稱和版本，例如: spring-core-5.3.4-SNAPSHOT.jar => sprint-core, 5.3.4-SNAPSHOT
從 zip reader 讀取被壓縮的文件
判斷文件類型
- 調(diào)用parseArtifact進(jìn)行遞歸解析
- 將返回的innerLibs放到 libs對(duì)象中
- 從 MANIFEST.MF 文件中解析出manifest返回
- 從 properties 文件中解析 groupid, artifactid, version 并返回
- 將上述信息放到 libs 對(duì)象中
- 如果是 pom.properties
- 如果是 MANIFEST.MF
- 如果是 jar/war/ear 等文件
如果找不到 artifactid or groupid
- 根據(jù)jar sha256查詢對(duì)應(yīng)的包信息
- 找到直接返回
返回解析出來(lái)的libs

func parseArtifact(c conf, fileName string, r io.ReadCloser) ([]types.Library, error) { 
  defer r.Close() 
  b, err := ioutil.ReadAll(r) 
  if err != nil { 
    return nil, xerrors.Errorf("unable to read the jar file: %w", err) 
  } 
  zr, err := zip.NewReader(bytes.NewReader(b), int64(len(b))) 
  if err != nil { 
    return nil, xerrors.Errorf("zip error: %w", err) 
  } 
 
  fileName = filepath.Base(fileName) 
  fileProps := parseFileName(fileName) 
 
  var libs []types.Library 
  var m manifest 
  var foundPomProps bool 
 
  for _, fileInJar := range zr.File { 
    switch { 
    case filepath.Base(fileInJar.Name) == "pom.properties": 
      props, err := parsePomProperties(fileInJar) 
      if err != nil { 
        return nil, xerrors.Errorf("failed to parse %s: %w", fileInJar.Name, err) 
      } 
      libs = append(libs, props.library()) 
      if fileProps.artifactID == props.artifactID && fileProps.version == props.version { 
        foundPomProps = true 
      } 
    case filepath.Base(fileInJar.Name) == "MANIFEST.MF": 
      m, err = parseManifest(fileInJar) 
      if err != nil { 
        return nil, xerrors.Errorf("failed to parse MANIFEST.MF: %w", err) 
      } 
    case isArtifact(fileInJar.Name): 
      fr, err := fileInJar.Open() 
      if err != nil { 
        return nil, xerrors.Errorf("unable to open %s: %w", fileInJar.Name, err) 
      } 
 
      // 遞歸解析 jar/war/ear  
      innerLibs, err := parseArtifact(c, fileInJar.Name, fr) 
      if err != nil { 
        return nil, xerrors.Errorf("failed to parse %s: %w", fileInJar.Name, err) 
      } 
      libs = append(libs, innerLibs...) 
    } 
  } 
 
  // 如果找到了 pom.properties 文件，則直接返回libs對(duì)象 
  if foundPomProps { 
    return libs, nil 
  } 
  // 如果沒(méi)有找到 pom.properties 文件，則解析MANIFEST.MF 文件 
  manifestProps := m.properties() 
  if manifestProps.valid() { 
    // 這里即使找到了 artifactid or groupid 也有可能是非法的。這里會(huì)訪問(wèn) maven等倉(cāng)庫(kù)確認(rèn) jar包是否真正存在 
    if ok, _ := exists(c, manifestProps); ok { 
      return append(libs, manifestProps.library()), nil 
    } 
  } 
  p, err := searchBySHA1(c, b) 
  if err == nil { 
    return append(libs, p.library()), nil 
  } else if !xerrors.Is(err, ArtifactNotFoundErr) { 
    return nil, xerrors.Errorf("failed to search by SHA1: %w", err) 
  } 
  return libs, nil 
}