snyk-docker-plugin

  • Version 8.0.1
  • Published
  • 759 kB
  • 26 dependencies
  • Apache-2.0 license

Install

npm i snyk-docker-plugin
yarn add snyk-docker-plugin
pnpm add snyk-docker-plugin

Overview

Snyk CLI docker plugin

Index

Functions

function analyseDockerfile

analyseDockerfile: (contents: string) => Promise<DockerFileAnalysis>;

    function display

    display: (
    scanResults: ScanResult[],
    testResults: TestResult[],
    errors: string[],
    options?: Options
    ) => Promise<string>;

      function extractContent

      extractContent: (
      extractActions: ExtractAction[],
      options?: Partial<PluginOptions>
      ) => Promise<ExtractionResult>;

        function parseDockerfile

        parseDockerfile: (content: string) => Dockerfile;

          function scan

          scan: (options?: Partial<PluginOptions>) => Promise<PluginResponse>;

            function updateDockerfileBaseImageName

            updateDockerfileBaseImageName: (
            contents: string,
            newBaseImageName: string
            ) => UpdateDockerfileBaseImageNameResult;
            • Updates the image name of the last from stage, after resolving all aliases

              Parameter contents

              Contents of the Dockerfile to update

              Parameter newBaseImageName

              New base image name Dockerfile contents should be updated to

            Interfaces

            interface AutoDetectedUserInstructions

            interface AutoDetectedUserInstructions {}

              property dockerfileLayers

              dockerfileLayers: DockerFileLayers;

                property dockerfilePackages

                dockerfilePackages: DockerFilePackages;

                  interface Binary

                  interface Binary {}

                    property name

                    name: string;

                      property version

                      version: string;

                        interface ContainerTarget

                        interface ContainerTarget {}

                          property image

                          image: string;

                            interface DockerFileAnalysis

                            interface DockerFileAnalysis {}

                              property baseImage

                              baseImage?: string;

                                property dockerfileLayers

                                dockerfileLayers: DockerFileLayers;

                                  property dockerfilePackages

                                  dockerfilePackages: DockerFilePackages;

                                    property error

                                    error?: {
                                    code: DockerFileAnalysisErrorCode;
                                    };

                                      interface Fact

                                      interface Fact {}
                                      • A collection of things that were found as part of a scan. As the developer and owner, you are responsible for defining and maintaining your own Facts. Examples of facts: a dependency graph, a list of file content hashes, Dockerfile analysis. See FactType.

                                      property data

                                      data: any;

                                        property type

                                        type: FactType;

                                          interface Identity

                                          interface Identity {}
                                          • The identity of a scan result allows to uniquely locate "what" you found. Any differences in the identity influences how a Project is created in Snyk and can result in a completely different Project (for example, if "args.targetFramework" differs).

                                          property args

                                          args?: { [key: string]: string };

                                            property targetFile

                                            targetFile?: string;

                                              property type

                                              type: string;
                                              • This used to be represented as "packageManager" but now can contain any sensible ecosystem type. Examples: dockerfile, cpp, terraform-module, deb, npm, and so on.

                                              interface ManifestFile

                                              interface ManifestFile {}

                                                property contents

                                                contents: string;
                                                • Base64-encoded file contents. We use Base64 to avoid any assumptions about the original file encoding, which is difficult to infer and may be corrupted when the data is transferred over the network.

                                                property name

                                                name: string;

                                                  property path

                                                  path: string;

                                                    interface PluginResponse

                                                    interface PluginResponse {}

                                                      property scanResults

                                                      scanResults: ScanResult[];
                                                      • The first result is guaranteed to be the OS dependencies scan result.

                                                      interface ScanResult

                                                      interface ScanResult {}

                                                        property facts

                                                        facts: Fact[];
                                                        • Facts are the collection of things you found.

                                                        property identity

                                                        identity: Identity;
                                                        • Identity defines "what" you found.

                                                        property name

                                                        name?: string;
                                                        • User-friendly name to use as the name of the Project that Snyk creates.

                                                        property policy

                                                        policy?: string;
                                                        • Contains the Snyk policy file content.

                                                        property target

                                                        target: ContainerTarget;
                                                        • The target defines "where" you found this scan result.

                                                        property targetReference

                                                        targetReference?: string;
                                                        • A reference for differentiating project versions, e.g., branch names, versions, etc.

                                                        Enums

                                                        enum DockerFileAnalysisErrorCode

                                                        enum DockerFileAnalysisErrorCode {
                                                        BASE_IMAGE_NAME_NOT_FOUND = 'BASE_IMAGE_NAME_NOT_FOUND',
                                                        BASE_IMAGE_NON_RESOLVABLE = 'BASE_IMAGE_NON_RESOLVABLE',
                                                        }

                                                          member BASE_IMAGE_NAME_NOT_FOUND

                                                          BASE_IMAGE_NAME_NOT_FOUND = 'BASE_IMAGE_NAME_NOT_FOUND'

                                                            member BASE_IMAGE_NON_RESOLVABLE

                                                            BASE_IMAGE_NON_RESOLVABLE = 'BASE_IMAGE_NON_RESOLVABLE'

                                                              enum UpdateDockerfileBaseImageNameErrorCode

                                                              enum UpdateDockerfileBaseImageNameErrorCode {
                                                              BASE_IMAGE_NAME_FRAGMENTED = 'BASE_IMAGE_NAME_FRAGMENTED',
                                                              BASE_IMAGE_NAME_NOT_FOUND = 'BASE_IMAGE_NAME_NOT_FOUND',
                                                              DOCKERFILE_GENERATION_FAILED = 'DOCKERFILE_GENERATION_FAILED',
                                                              }

                                                                member BASE_IMAGE_NAME_FRAGMENTED

                                                                BASE_IMAGE_NAME_FRAGMENTED = 'BASE_IMAGE_NAME_FRAGMENTED'

                                                                  member BASE_IMAGE_NAME_NOT_FOUND

                                                                  BASE_IMAGE_NAME_NOT_FOUND = 'BASE_IMAGE_NAME_NOT_FOUND'

                                                                    member DOCKERFILE_GENERATION_FAILED

                                                                    DOCKERFILE_GENERATION_FAILED = 'DOCKERFILE_GENERATION_FAILED'

                                                                      Type Aliases

                                                                      type FactType

                                                                      type FactType =
                                                                      | 'autoDetectedUserInstructions'
                                                                      | 'depGraph'
                                                                      | 'dockerfileAnalysis'
                                                                      | 'imageCreationTime'
                                                                      | 'imageId'
                                                                      | 'imageLabels'
                                                                      // Collects the file names of the individual .tar layers found in the scanned image.
                                                                      | 'imageLayers'
                                                                      // Package manager manifests (e.g. requirements.txt, Gemfile.lock) collected as part of an application scan.
                                                                      | 'imageManifestFiles'
                                                                      | 'imageNames'
                                                                      | 'imageOsReleasePrettyName'
                                                                      | 'imageSizeBytes'
                                                                      // Hashes of extracted *.jar binaries, hashed with sha1 algorithm
                                                                      | 'jarFingerprints'
                                                                      // Hashes of executables not installed by a package manager (e.g. if they were copied straight onto the image).
                                                                      | 'keyBinariesHashes'
                                                                      | 'loadedPackages'
                                                                      | 'ociDistributionMetadata'
                                                                      | 'rootFs'
                                                                      // Used for application dependencies scanning; shows which files were used in the analysis of the dependencies.
                                                                      | 'testedFiles'
                                                                      // Application files observed in the image
                                                                      | 'applicationFiles';

                                                                        Namespaces

                                                                        namespace dockerFile

                                                                        module 'lib/dockerfile/index.ts' {}

                                                                          function analyseDockerfile

                                                                          analyseDockerfile: (contents: string) => Promise<DockerFileAnalysis>;

                                                                            function getDockerfileBaseImageName

                                                                            getDockerfileBaseImageName: (
                                                                            dockerfile: Dockerfile
                                                                            ) => GetDockerfileBaseImageNameResult;
                                                                            • Return the image name of the last from stage, after resolving all aliases

                                                                              Parameter dockerfile

                                                                              Dockerfile to use for retrieving the last stage image name

                                                                            function getPackagesFromDockerfile

                                                                            getPackagesFromDockerfile: (dockerfile: Dockerfile) => DockerFilePackages;

                                                                              function instructionDigest

                                                                              instructionDigest: (instruction: any) => string;

                                                                                function parseDockerfile

                                                                                parseDockerfile: (content: string) => Dockerfile;

                                                                                  function readDockerfileAndAnalyse

                                                                                  readDockerfileAndAnalyse: (
                                                                                  dockerfilePath?: string
                                                                                  ) => Promise<DockerFileAnalysis | undefined>;

                                                                                    function updateDockerfileBaseImageName

                                                                                    updateDockerfileBaseImageName: (
                                                                                    contents: string,
                                                                                    newBaseImageName: string
                                                                                    ) => UpdateDockerfileBaseImageNameResult;
                                                                                    • Updates the image name of the last from stage, after resolving all aliases

                                                                                      Parameter contents

                                                                                      Contents of the Dockerfile to update

                                                                                      Parameter newBaseImageName

                                                                                      New base image name Dockerfile contents should be updated to

                                                                                    interface DockerFileAnalysis

                                                                                    interface DockerFileAnalysis {}

                                                                                      property baseImage

                                                                                      baseImage?: string;

                                                                                        property dockerfileLayers

                                                                                        dockerfileLayers: DockerFileLayers;

                                                                                          property dockerfilePackages

                                                                                          dockerfilePackages: DockerFilePackages;

                                                                                            property error

                                                                                            error?: {
                                                                                            code: DockerFileAnalysisErrorCode;
                                                                                            };

                                                                                              namespace facts

                                                                                              module 'lib/facts.ts' {}

                                                                                                interface ApplicationFilesFact

                                                                                                interface ApplicationFilesFact {}

                                                                                                  property data

                                                                                                  data: ApplicationFiles[];

                                                                                                    property type

                                                                                                    type: 'applicationFiles';

                                                                                                      interface AutoDetectedUserInstructionsFact

                                                                                                      interface AutoDetectedUserInstructionsFact {}

                                                                                                        property data

                                                                                                        data: AutoDetectedUserInstructions;

                                                                                                          property type

                                                                                                          type: 'autoDetectedUserInstructions';

                                                                                                            interface DepGraphFact

                                                                                                            interface DepGraphFact {}

                                                                                                              property data

                                                                                                              data: DepGraph;

                                                                                                                property type

                                                                                                                type: 'depGraph';

                                                                                                                  interface DockerfileAnalysisFact

                                                                                                                  interface DockerfileAnalysisFact {}

                                                                                                                    property data

                                                                                                                    data: DockerFileAnalysis;

                                                                                                                      property type

                                                                                                                      type: 'dockerfileAnalysis';

                                                                                                                        interface ImageCreationTimeFact

                                                                                                                        interface ImageCreationTimeFact {}

                                                                                                                          property data

                                                                                                                          data: string;

                                                                                                                            property type

                                                                                                                            type: 'imageCreationTime';

                                                                                                                              interface ImageIdFact

                                                                                                                              interface ImageIdFact {}

                                                                                                                                property data

                                                                                                                                data: string;

                                                                                                                                  property type

                                                                                                                                  type: 'imageId';

                                                                                                                                    interface ImageLabels

                                                                                                                                    interface ImageLabels {}

                                                                                                                                      property data

                                                                                                                                      data: {
                                                                                                                                      [key: string]: string;
                                                                                                                                      };

                                                                                                                                        property type

                                                                                                                                        type: 'imageLabels';

                                                                                                                                          interface ImageLayersFact

                                                                                                                                          interface ImageLayersFact {}

                                                                                                                                            property data

                                                                                                                                            data: string[];

                                                                                                                                              property type

                                                                                                                                              type: 'imageLayers';

                                                                                                                                                interface ImageManifestFilesFact

                                                                                                                                                interface ImageManifestFilesFact {}

                                                                                                                                                  property data

                                                                                                                                                  data: ManifestFile[];

                                                                                                                                                    property type

                                                                                                                                                    type: 'imageManifestFiles';

                                                                                                                                                      interface ImageNamesFact

                                                                                                                                                      interface ImageNamesFact {}

                                                                                                                                                        property data

                                                                                                                                                        data: ImageNameInfo;

                                                                                                                                                          property type

                                                                                                                                                          type: 'imageNames';

                                                                                                                                                            interface ImageOsReleasePrettyNameFact

                                                                                                                                                            interface ImageOsReleasePrettyNameFact {}

                                                                                                                                                              property data

                                                                                                                                                              data: string;

                                                                                                                                                                property type

                                                                                                                                                                type: 'imageOsReleasePrettyName';

                                                                                                                                                                  interface ImageSizeBytesFact

                                                                                                                                                                  interface ImageSizeBytesFact {}

                                                                                                                                                                    property data

                                                                                                                                                                    data: number;

                                                                                                                                                                      property type

                                                                                                                                                                      type: 'imageSizeBytes';

                                                                                                                                                                        interface JarFingerprintsFact

                                                                                                                                                                        interface JarFingerprintsFact {}

                                                                                                                                                                          property data

                                                                                                                                                                          data: {
                                                                                                                                                                          fingerprints: JarFingerprint[];
                                                                                                                                                                          origin: string;
                                                                                                                                                                          path: string;
                                                                                                                                                                          };

                                                                                                                                                                            property type

                                                                                                                                                                            type: 'jarFingerprints';

                                                                                                                                                                              interface KeyBinariesHashesFact

                                                                                                                                                                              interface KeyBinariesHashesFact {}

                                                                                                                                                                                property data

                                                                                                                                                                                data: string[];

                                                                                                                                                                                  property type

                                                                                                                                                                                  type: 'keyBinariesHashes';

                                                                                                                                                                                    interface LoadedPackagesFact

                                                                                                                                                                                    interface LoadedPackagesFact {}

                                                                                                                                                                                      property data

                                                                                                                                                                                      data: string;

                                                                                                                                                                                        property type

                                                                                                                                                                                        type: 'loadedPackages';

                                                                                                                                                                                          interface OCIDistributionMetadataFact

                                                                                                                                                                                          interface OCIDistributionMetadataFact {}

                                                                                                                                                                                            property data

                                                                                                                                                                                            data: OCIDistributionMetadata;

                                                                                                                                                                                              property type

                                                                                                                                                                                              type: 'ociDistributionMetadata';

                                                                                                                                                                                                interface RootFsFact

                                                                                                                                                                                                interface RootFsFact {}

                                                                                                                                                                                                  property data

                                                                                                                                                                                                  data: string[];

                                                                                                                                                                                                    property type

                                                                                                                                                                                                    type: 'rootFs';

                                                                                                                                                                                                      interface TestedFilesFact

                                                                                                                                                                                                      interface TestedFilesFact {}

                                                                                                                                                                                                        property data

                                                                                                                                                                                                        data: string[];

                                                                                                                                                                                                          property type

                                                                                                                                                                                                          type: 'testedFiles';

                                                                                                                                                                                                            Package Files (10)

                                                                                                                                                                                                            Dependencies (26)

                                                                                                                                                                                                            Dev Dependencies (17)

                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                            No peer dependencies.

                                                                                                                                                                                                            Badge

                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/snyk-docker-plugin.

                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/snyk-docker-plugin)
                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/snyk-docker-plugin"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>