scan

Documentation

Index

• Variables
• type Backend
• type Service
  • func NewService(backend Backend, ar artifact.Artifact) Service
  • func (s Service) ScanArtifact(ctx context.Context, options types.ScanOptions) (types.Report, error)

Variables

var RemoteArchiveSet = wire.NewSet(
	aimage.NewArtifact,
	image.NewArchiveImage,
	RemoteSuperSet,
)

RemoteArchiveSet binds remote archive dependencies

var RemoteDockerSet = wire.NewSet(
	aimage.NewArtifact,
	image.NewContainerImage,
	RemoteSuperSet,
)

RemoteDockerSet binds remote docker dependencies

var RemoteFilesystemSet = wire.NewSet(
	flocal.ArtifactSet,
	RemoteSuperSet,
)

RemoteFilesystemSet binds filesystem dependencies for client/server mode

var RemoteRepositorySet = wire.NewSet(
	repo.ArtifactSet,
	RemoteSuperSet,
)

RemoteRepositorySet binds repository dependencies for client/server mode

var RemoteSBOMSet = wire.NewSet(
	sbom.NewArtifact,
	RemoteSuperSet,
)

RemoteSBOMSet binds sbom dependencies for client/server mode

var RemoteSuperSet = wire.NewSet(

	cache.NewRemoteCache,
	wire.Bind(new(cache.ArtifactCache), new(*cache.RemoteCache)),

	client.NewService,
	wire.Value([]client.Option(nil)),
	wire.Bind(new(Backend), new(client.Service)),
	NewService,
)

RemoteSuperSet is used in the client mode

var RemoteVMSet = wire.NewSet(
	vm.ArtifactSet,
	RemoteSuperSet,
)

RemoteVMSet binds vm dependencies for client/server mode

var StandaloneArchiveSet = wire.NewSet(
	image.NewArchiveImage,
	aimage.NewArtifact,
	StandaloneSuperSet,
)

StandaloneArchiveSet binds archive scan dependencies

var StandaloneDockerSet = wire.NewSet(
	image.NewContainerImage,
	aimage.NewArtifact,
	StandaloneSuperSet,
)

StandaloneDockerSet binds docker dependencies

var StandaloneFilesystemSet = wire.NewSet(
	flocal.ArtifactSet,
	StandaloneSuperSet,
)

StandaloneFilesystemSet binds filesystem dependencies

var StandaloneRepositorySet = wire.NewSet(
	repo.ArtifactSet,
	StandaloneSuperSet,
)

StandaloneRepositorySet binds repository dependencies

var StandaloneSBOMSet = wire.NewSet(
	sbom.NewArtifact,
	StandaloneSuperSet,
)

StandaloneSBOMSet binds sbom dependencies

var StandaloneSuperSet = wire.NewSet(

	cache.New,
	wire.Bind(new(cache.ArtifactCache), new(cache.Cache)),
	wire.Bind(new(cache.LocalArtifactCache), new(cache.Cache)),

	local.SuperSet,
	wire.Bind(new(Backend), new(local.Service)),
	NewService,
)

StandaloneSuperSet is used in the standalone mode

var StandaloneVMSet = wire.NewSet(
	vm.ArtifactSet,
	StandaloneSuperSet,
)

StandaloneVMSet binds vm dependencies

Types

type Backend

type Backend interface {
	Scan(ctx context.Context, target, artifactKey string, blobKeys []string, options types.ScanOptions) (
		response types.ScanResponse, err error)
}

Backend defines the interface for security scanning implementations. It can be either local.Service for standalone scanning or remote.Service for client/server mode scanning. The backend handles various types of security scanning including vulnerability, misconfiguration, secret, and license scanning.

type Service

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

Service is the main service that coordinates security scanning operations. It uses either local.Service or remote.Service as its backend implementation.

func NewService

func NewService(backend Backend, ar artifact.Artifact) Service

NewService creates a new Service instance with the specified backend implementation and artifact handler.

func (Service) ScanArtifact

func (s Service) ScanArtifact(ctx context.Context, options types.ScanOptions) (types.Report, error)

ScanArtifact performs security scanning on the specified artifact. It first inspects the artifact to gather necessary information, then delegates the actual scanning to the configured backend implementation.