trivy

Documentation

Index

• Constants
• type BasicAuth
• type BearerAuth
• type CVSSInfo
• type Format
• type ImageRef
• type Layer
• type Metadata
• type MockWrapper
  • func NewMockWrapper() *MockWrapper
  • func (w *MockWrapper) GetVersion() (VersionInfo, error)
  • func (w *MockWrapper) Scan(imageRef ImageRef, opt ScanOption) (Report, error)
• type NoAuth
• type RegistryAuth
• type Report
• type ScanOption
• type ScanReport
• type ScanResult
• type ScanTarget
  • func (t ScanTarget) Auth() RegistryAuth
  • func (t ScanTarget) Clean() error
  • func (t ScanTarget) Name() (string, error)
  • func (t ScanTarget) NonSSL() bool
• type Target
• type VersionInfo
• type Vulnerability
• type Wrapper
  • func NewWrapper(config etc.Trivy, ambassador ext.Ambassador) Wrapper

Constants

const SchemaVersion = 2

Types

type BasicAuth

type BasicAuth struct {
	Username string
	Password string
}

type BearerAuth

type BearerAuth struct {
	Token string
}

type CVSSInfo

type CVSSInfo struct {
	V2Vector string   `json:"V2Vector,omitempty"`
	V3Vector string   `json:"V3Vector,omitempty"`
	V2Score  *float32 `json:"V2Score,omitempty"`
	V3Score  *float32 `json:"V3Score,omitempty"`
}

type Format

type Format string

const (
	FormatJSON      Format = "json"
	FormatSPDX      Format = "spdx-json"
	FormatCycloneDX Format = "cyclonedx"
)

type ImageRef

type ImageRef struct {
	Name   string
	Auth   RegistryAuth
	NonSSL bool
}

type Layer

type Layer struct {
	Digest string `json:"Digest"`
	DiffID string `json:"DiffID"`
}

type Metadata

type Metadata struct {
	NextUpdate time.Time `json:"NextUpdate"`
	UpdatedAt  time.Time `json:"UpdatedAt"`
}

type MockWrapper

type MockWrapper struct {
	mock.Mock
}

func NewMockWrapper

func NewMockWrapper() *MockWrapper

func (*MockWrapper) GetVersion

func (w *MockWrapper) GetVersion() (VersionInfo, error)

func (*MockWrapper) Scan

func (w *MockWrapper) Scan(imageRef ImageRef, opt ScanOption) (Report, error)

type NoAuth

type NoAuth struct {
}

type RegistryAuth

type RegistryAuth interface {
}

RegistryAuth wraps registry credentials.

type Report

type Report struct {
	SBOM            any
	Vulnerabilities []Vulnerability
}

type ScanOption

type ScanOption struct {
	Format Format
}

type ScanReport

type ScanReport struct {
	SchemaVersion int
	Results       []ScanResult `json:"Results"`
}

type ScanResult

type ScanResult struct {
	Target          string          `json:"Target"`
	Vulnerabilities []Vulnerability `json:"Vulnerabilities"`
}

type ScanTarget

type ScanTarget struct {
	// contains filtered or unexported fields
}

func (ScanTarget) Auth

func (t ScanTarget) Auth() RegistryAuth

func (ScanTarget) Clean

func (t ScanTarget) Clean() error

func (ScanTarget) Name

func (t ScanTarget) Name() (string, error)

func (ScanTarget) NonSSL

func (t ScanTarget) NonSSL() bool

type Target

type Target string

const (
	TargetSBOM  Target = "sbom"
	TargetImage Target = "image"
)

type VersionInfo

type VersionInfo struct {
	Version         string    `json:"Version,omitempty"`
	VulnerabilityDB *Metadata `json:"VulnerabilityDB"`
	JavaDB          *Metadata `json:"JavaDB"`
}

type Vulnerability

type Vulnerability struct {
	VulnerabilityID  string              `json:"VulnerabilityID"`
	PkgName          string              `json:"PkgName"`
	InstalledVersion string              `json:"InstalledVersion"`
	FixedVersion     string              `json:"FixedVersion"`
	Title            string              `json:"Title"`
	Description      string              `json:"Description"`
	Severity         string              `json:"Severity"`
	References       []string            `json:"References"`
	PrimaryURL       string              `json:"PrimaryURL"`
	Layer            *Layer              `json:"Layer"`
	CVSS             map[string]CVSSInfo `json:"CVSS"`
	CweIDs           []string            `json:"CweIDs"`
}

type Wrapper

type Wrapper interface {
	Scan(imageRef ImageRef, opt ScanOption) (Report, error)
	GetVersion() (VersionInfo, error)
}

func NewWrapper

func NewWrapper(config etc.Trivy, ambassador ext.Ambassador) Wrapper