Diese Seite wurde von der Cloud Translation API übersetzt.

Betriebssystempakete automatisch scannen

In diesem Dokument erfahren Sie, wie Sie die Container Scanning API aktivieren, ein Image per Push an Artifact Registry übertragen und die Liste der im Image gefundenen Sicherheitslücken aufrufen.

Artefaktanalyse bietet Informationen zu Sicherheitslücken für die Container-Images in Artifact Registry. Die Metadaten werden als Hinweise gespeichert. Für jede mit einem Image verknüpfte Instanz eines Hinweises wird ein Vorkommen erstellt. Weitere Informationen finden Sie in der Übersicht und in der Preisdokumentation.

Hinweise

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Artifact Registry and Container Scanning APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Artifact Registry and Container Scanning APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

gcloud init

Erstellen Sie ein Docker-Repository in Artifact Registry und übertragen Sie ein Container-Image in das Repository. Wenn Sie mit Artifact Registry nicht vertraut sind, lesen Sie die Docker-Kurzanleitung.

Durch die Aktivierung dieser API wird auch das Scannen von Sprachpaketen in Artifact Registry aktiviert. Unterstützte Pakettypen

Image-Sicherheitslücken ansehen

Die Artefaktanalyse scannt neue Images, wenn sie in Artifact Registry hochgeladen werden. Bei diesem Scan werden Informationen zu den Systempaketen im Container extrahiert.

Sie können Sicherheitslücken für Ihre Images in der Registry mit der Google Cloud -Konsole, der Google Cloud CLI oder der Container Analysis API aufrufen. Wenn ein Image Sicherheitslücken aufweist, können Sie dann die Details abrufen.

Die Artefaktanalyse aktualisiert nur die Metadaten für Images, die in den letzten 30 Tagen per Push oder Pull übertragen wurden. Nach 30 Tagen werden die Metadaten nicht mehr aktualisiert und die Ergebnisse sind veraltet. Außerdem archiviert die Artefaktanalyse Metadaten, die seit mehr als 90 Tagen inaktiv sind. Diese Metadaten sind dann nicht mehr in der Google Cloud -Konsole, in gcloud oder über die API verfügbar. Wenn Sie ein Image mit veralteten oder archivierten Metadaten noch einmal scannen möchten, rufen Sie dieses Image per Pull ab. Das Aktualisieren der Metadaten kann bis zu 24 Stunden dauern.

Vorkommen in der Google Cloud -Console ansehen

So sehen Sie die Sicherheitslücken in einem Image:

Rufen Sie die Liste der Repositories ab.

Zur Seite „Repositories“
Klicken Sie in der Liste der Repositories auf ein Repository.
Klicken Sie in der Liste der Bilder auf einen Bildnamen.

Alle Sicherheitslücken für jeden Image-Digest werden in der Spalte Sicherheitslücken angezeigt.
Wenn Sie die Liste der Sicherheitslücken für ein Image aufrufen möchten, klicken Sie auf den Link in der Spalte Vulnerabilities (Sicherheitslücken).

Im Bereich Scanergebnisse wird eine Zusammenfassung der gescannten Pakettypen, der Gesamtzahl der Sicherheitslücken, der Sicherheitslücken mit verfügbaren Korrekturen, der Sicherheitslücken ohne Korrekturen und des effektiven Schweregrads angezeigt.

In der Tabelle mit den Sicherheitslücken sind für jede gefundene Sicherheitslücke der Name der Common Vulnerabilities and Exposures (CVE), der effektive Schweregrad, die CVSS-Punktzahl (Common Vulnerability Scoring System), Korrekturen (sofern verfügbar), der Name des Pakets, das die Sicherheitslücke enthält, und der Pakettyp aufgeführt.

In derGoogle Cloud Console werden in dieser Tabelle bis zu 1.200 Sicherheitslücken pro Seite angezeigt. Sie können diese Dateien filtern und sortieren, um eine bestimmte Datei, ein bestimmtes Verzeichnis, eine bestimmte Ebene oder einen bestimmten Dateityp nach Dateiendung zu prüfen.
Klicken Sie auf den Namen der CVE, um Details zu einer bestimmten CVE aufzurufen.
Wenn Sie Details zum Auftreten von Sicherheitslücken wie Versionsnummer und betroffene Stelle aufrufen möchten, klicken Sie in der Zeile mit dem Namen der Sicherheitslücke auf Anzeigen oder Behobene anzeigen. Der Linktext lautet Ansehen für Sicherheitslücken ohne Korrektur und Behobene ansehen für Sicherheitslücken, bei denen eine Korrektur angewendet wurde.

Sicherheitslücken in einer bestimmten Ebene ansehen

Artefaktanalyse stellt schichtspezifische Metadaten bereit, mit denen Sie ermitteln können, welches Paket Sicherheitslücken enthält und mit welchem Docker-Build-Befehl diese Schicht eingeführt wurde.

So rufen Sie schichtbasierte Metadaten zu Sicherheitslücken in der Google Cloud -Console auf:

Öffnen Sie in Artifact Registry die Liste Ihrer Repositories.

Zur Seite „Repositories“
Klicken Sie auf der Seite Repositories auf ein Repository.
Klicken Sie auf der Seite Repository Details (Repository-Details) auf ein Bild.
Klicken Sie in der Liste der Image-Versionen auf einen Image-Digest.
Klicken Sie auf der Seite mit den Details zum Image-Digest auf den Tab Sicherheitslücken.

Wenn schichtbasierte Metadaten verfügbar sind, wird in der Artefaktanalyse in der Leiste Ebene eine auswählbare Liste von Ebenen angezeigt:
Klicken Sie auf das Drop-down-Menü für Ebenen, um die Liste der Ebenen aufzurufen.

Eine Drop-down-Liste mit einer nummerierten Liste von Ebenen wird geöffnet. Ebene 0 stellt die unterste Ebene dar, wobei jede folgende Ebene auf der vorherigen aufbaut. Es werden nur Ebenen angezeigt, in denen Sicherheitslücken gefunden wurden.

Für jedes Layer zeigt die Artefaktanalyse den Docker-Befehl, der zum Erstellen des Layers verwendet wurde, und die Anzahl der in diesem Layer gefundenen Sicherheitslücken.
Wenn Sie mehr über die Sicherheitslücken in einer bestimmten Ebene erfahren möchten, wählen Sie eine Ebene aus der Liste aus.

Die Tabelle mit den Sicherheitslücken wird aktualisiert und enthält nur die Sicherheitslücken, die in der ausgewählten Ebene gefunden wurden. Sie können weitere Filter anwenden oder bestimmte Sicherheitslücken untersuchen.
Klicken Sie neben einer Sicherheitslücke auf ANSEHEN oder KORREKTUR ANSEHEN, um detailliertere Informationen zur Sicherheitslücke aufzurufen.

In der Seitenleiste Details zur Sicherheitslücke werden Dateipfade angezeigt, in denen Pakete Sicherheitslücken aufweisen.
Bewegen Sie den Mauszeiger in der Tabelle Dateispeicherorte auf das Fragezeichen, um zusätzliche Metadaten für die Ebene aufzurufen.

In einem Dialogfeld werden der Layer-Index, der Layer-Build-Befehl, der Layer-Digest und das Basis-Image angezeigt, in dem Sie die Sicherheitslücke beheben können.

Vorkommen mit gcloud ansehen

Führen Sie den Befehl gcloud artifacts docker images list aus, um Vorkommen für ein Image in Artifact Registry aufzurufen:

gcloud artifacts docker images list --show-occurrences \
    LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

Wobei:

LOCATION ist der regionale oder multiregionale Speicherort für das Repository.
PROJECT_ID ist Ihre Projekt-ID in der Console von Google Cloud .
REPOSITORY ist der Name des Repositorys, in dem das Image gespeichert ist.
IMAGE_ID ist der Name des Images im Repository. Mit diesem Befehl können Sie kein Image-Tag angeben.

Standardmäßig gibt der Befehl die zehn letzten Bilder zurück. Wenn Sie eine andere Anzahl von Bildern anzeigen möchten, verwenden Sie das Flag --show-occurrences-from. Der folgende Befehl gibt beispielsweise die 25 neuesten Bilder zurück:

gcloud artifacts docker images list --show-occurrences-from=25 \
    us-central1-docker.pkg.dev/my-project/my-repo/my-image

Die Ausgabe sieht etwa so aus:

Beispiel für die Bildausgabe

  {
      "name": "projects/my-project/locations/us-central1/occurrences/22d3edfb-34f2-4d3f-be08-fd90c549f010",
      "resource": {
        "uri": "https://us-central1-docker.pkg.dev/my-project/my-repo/golang-nginx@sha256:5b54ef20748417ccdb0b87afedf98c44e699e2f59bd6cv48cbdc1ca2e72c80e3"
      },
      "noteName": "projects/my-project/locations/us-central1/notes/CVE-2005-2541",
      "kind": "VULNERABILITY",
      "createTime": "2025-01-21T15:57:01.238832Z",
      "updateTime": "2025-01-21T15:57:01.238832Z",
      "vulnerability": {
        "severity": "CRITICAL",
        "cvssScore": 10,
        "packageIssue": [
          {
            "affectedLocation": {
              "cpeUri": "cpe:/o:debian:debian_linux:12",
              "package": "tar",
              "version": {
                "name": "1.34+dfsg",
                "revision": "1.2+deb12u1",
                "kind": "NORMAL"
              }
            },
            "fixedLocation": {
              "cpeUri": "cpe:/o:debian:debian_linux:12",
              "package": "tar",
              "version": {
                "kind": "MAXIMUM"
              }
            },
            "packageType": "OS",
            "effectiveSeverity": "LOW",
            "file_location": [
                {
                "file_path": "/var/lib/dpkg/status",
                "layerDetails": {
                  "index": 0,
                  "diffID": "sha256:123",
                  "buildCommand": "FROM golang:example_sha256",
                  "BaseImages": [
                    {
                      "name": "library/golang",
                    },
                  ],
                },
              },
            ],
          }
        ],
        "shortDescription": "CVE-2005-2541",
        "longDescription": "NIST vectors: AV:N/AC:L/Au:N/C:C/I:C/A:C",
        "relatedUrls": [
          {
            "url": "https://security-tracker.debian.org/tracker/CVE-2005-2541",
            "label": "More Info"
          }
        ],
        "effectiveSeverity": "LOW",
        "cvssVersion": "CVSS_VERSION_2",
        "cvssV2": {
          "baseScore": 10,
          "attackVector": "ATTACK_VECTOR_NETWORK",
          "attackComplexity": "ATTACK_COMPLEXITY_LOW",
          "authentication": "AUTHENTICATION_NONE",
          "confidentialityImpact": "IMPACT_COMPLETE",
          "integrityImpact": "IMPACT_COMPLETE",
          "availabilityImpact": "IMPACT_COMPLETE"
        }
      }
    }

Sicherheitslücken für ein Image-Tag ansehen

Geben Sie einen der folgenden Befehle ein, um Sicherheitslücken für ein Image-Tag aufzurufen:

gcloud artifacts docker images describe \
    LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID:TAG \
    --show-package-vulnerability

oder

gcloud artifacts docker images describe \
    LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID@sha256:HASH \
    --show-package-vulnerability

Wobei:

LOCATION ist der regionale oder multiregionale Speicherort für das Repository.
PROJECT_ID ist Ihre Projekt-ID in der Console von Google Cloud .
REPOSITORY ist der Name des Repositorys, in dem das Image gespeichert ist.
IMAGE_ID ist der Name des Images im Repository.
TAG ist das Image-Tag, über das Sie Informationen erhalten möchten.
HASH ist der Image-Digest.

Die Artefaktanalyse gibt Ergebnisse zurück, die packageType enthalten.

Vorkommen von Sicherheitslücken filtern

Verwenden Sie den Parameter --occurrence-filter, um Vorkommen von Sicherheitslücken zu filtern:

gcloud artifacts docker images list --show-occurrences \
    LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID \
    --occurrence-filter=FILTER_EXPRESSION

Wobei:

LOCATION ist der regionale oder multiregionale Speicherort für das Repository.
PROJECT_ID ist Ihre Projekt-ID in der Console von Google Cloud .
REPOSITORY ist der Name des Repositorys, in dem das Image gespeichert ist.
IMAGE_ID ist der Name des Images im Repository.
FILTER_EXPRESSION ist ein Beispiel für einen Filterausdruck in dem Format, das unter Vorkommen von Sicherheitslücken filtern erläutert wird.

Sicherheitslücken für eine bestimmte Ebene ansehen

Mit dem Feld layerDetails können Sie ermitteln, in welcher Ebene ein anfälliges Paket eingeführt wurde, und zusätzliche Informationen zu dieser Ebene aufrufen. Sehen Sie sich beispielsweise die folgende layerDetails-Ausgabe für ein Bild an:

  "layerDetails": {
    "index": 0,
    "diffID": "sha256:123",
    "buildCommand": "FROM golang:example_sha256",
    "BaseImages": [
      {
        "name": "library/golang",
      },
    ],
  }

Die Ausgabe zeigt, dass der Layer-Index im Container-Image 0 ist und der Layer-Hash sha256:123 lautet. Der Docker-Build-Befehl zum Erstellen dieser Ebene ist FROM golang:example_sha256. Die Ebene ist auch im Basis-Image library/golang enthalten.

Vorkommen mit der API oder mit Code ansehen

Wenn Sie Vorkommen für ein Bild aufrufen möchten, geben Sie Bilder mit einer URL im folgenden Format an:

LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

API

cURL verwenden

So rufen Sie eine Liste der Vorkommen in Ihrem Projekt ab:

 curl -X GET -H "Content-Type: application/json" -H \
    "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://containeranalysis.googleapis.com/v1/projects/PROJECT_ID/occurrences

So erhalten Sie eine Zusammenfassung der Sicherheitslücken in Ihrem Projekt:

 curl -X GET -H "Content-Type: application/json" -H \
    "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://containeranalysis.googleapis.com/v1/projects/PROJECT_ID/occurrences:vulnerabilitySummary

So rufen Sie Details zu einem bestimmten Vorkommen ab:

 curl -X GET -H "Content-Type: application/json" -H \
    "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://containeranalysis.googleapis.com/v1/projects/PROJECT_ID/occurrences/OCCURRENCE_ID

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Artefaktanalyse finden Sie unter Artifact Analysis-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Artifact Analysis Java API.

Richten Sie zur Authentifizierung bei Artefaktanalyse Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import com.google.cloud.devtools.containeranalysis.v1.ContainerAnalysisClient;
import io.grafeas.v1.GrafeasClient;
import io.grafeas.v1.Occurrence;
import io.grafeas.v1.ProjectName;
import java.io.IOException;
import java.lang.InterruptedException;

public class OccurrencesForImage {
  // Retrieves all the Occurrences associated with a specified image
  // Here, all Occurrences are simply printed and counted
  public static int getOccurrencesForImage(String resourceUrl, String projectId)
      throws IOException, InterruptedException {
    // String resourceUrl = "https://gcr.io/project/image@sha256:123";
    // String projectId = "my-project-id";
    final String projectName = ProjectName.format(projectId);
    final String filterStr = String.format("resourceUrl=\"%s\"", resourceUrl);

    // Initialize client that will be used to send requests. After completing all of your requests, 
    // call the "close" method on the client to safely clean up any remaining background resources.
    GrafeasClient client = ContainerAnalysisClient.create().getGrafeasClient();
    int i = 0;
    for (Occurrence o : client.listOccurrences(projectName, filterStr).iterateAll()) {
      // Write custom code to process each Occurrence here
      System.out.println(o.getName());
      i = i + 1;
    }
    return i;
  }
}

Go


import (
	"context"
	"fmt"
	"io"

	containeranalysis "cloud.google.com/go/containeranalysis/apiv1"
	"google.golang.org/api/iterator"
	grafeaspb "google.golang.org/genproto/googleapis/grafeas/v1"
)

// getOccurrencesForImage retrieves all the Occurrences associated with a specified image.
// Here, all Occurrences are simply printed and counted.
func getOccurrencesForImage(w io.Writer, resourceURL, projectID string) (int, error) {
	// Use this style of URL when you use Google Container Registry.
	// resourceURL := "https://gcr.io/my-project/my-repo/my-image"
	// Use this style of URL when you use Google Artifact Registry.
	// resourceURL := "https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image"
	ctx := context.Background()
	client, err := containeranalysis.NewClient(ctx)
	if err != nil {
		return -1, fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	req := &grafeaspb.ListOccurrencesRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Filter: fmt.Sprintf("resourceUrl=%q", resourceURL),
	}
	it := client.GetGrafeasClient().ListOccurrences(ctx, req)
	count := 0
	for {
		occ, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return -1, fmt.Errorf("occurrence iteration error: %w", err)
		}
		// Write custom code to process each Occurrence here.
		fmt.Fprintln(w, occ)
		count = count + 1
	}
	return count, nil
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample
 */
// const projectId = 'your-project-id', // Your GCP Project ID
// If you are using Google Container Registry
// const imageUrl = 'https://gcr.io/my-project/my-repo/my-image@sha256:123' // Image to attach metadata to
// If you are using Google Artifact Registry
// const imageUrl = 'https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image@sha256:123' // Image to attach metadata to

// Import the library and create a client
const {ContainerAnalysisClient} = require('@google-cloud/containeranalysis');
const client = new ContainerAnalysisClient();

const formattedParent = client.getGrafeasClient().projectPath(projectId);

// Retrieves all the Occurrences associated with a specified image
const [occurrences] = await client.getGrafeasClient().listOccurrences({
  parent: formattedParent,
  filter: `resourceUrl = "${imageUrl}"`,
});

if (occurrences.length) {
  console.log(`Occurrences for ${imageUrl}`);
  occurrences.forEach(occurrence => {
    console.log(`${occurrence.name}:`);
  });
} else {
  console.log('No occurrences found.');
}

Ruby

# resource_url = "The URL of the resource associated with the occurrence."
#                # e.g. https://gcr.io/project/image@sha256:123"
# project_id   = "The Google Cloud project ID of the occurrences to retrieve"

require "google/cloud/container_analysis"

# Initialize the client
client = Google::Cloud::ContainerAnalysis.container_analysis.grafeas_client

parent = client.project_path project: project_id
filter = "resourceUrl = \"#{resource_url}\""
count = 0
client.list_occurrences(parent: parent, filter: filter).each do |occurrence|
  # Process occurrence here
  puts occurrence
  count += 1
end
puts "Found #{count} occurrences"

Python

from google.cloud.devtools import containeranalysis_v1


def get_occurrences_for_image(resource_url: str, project_id: str) -> int:
    """Retrieves all the occurrences associated with a specified image.
    Here, all occurrences are simply printed and counted."""
    # resource_url = 'https://gcr.io/my-project/my-image@sha256:123'
    # project_id = 'my-gcp-project'

    filter_str = f'resourceUrl="{resource_url}"'
    client = containeranalysis_v1.ContainerAnalysisClient()
    grafeas_client = client.get_grafeas_client()
    project_name = f"projects/{project_id}"

    response = grafeas_client.list_occurrences(parent=project_name, filter=filter_str)
    count = 0
    for o in response:
        # do something with the retrieved occurrence
        # in this sample, we will simply count each one
        count += 1
    return count

Vorkommen in Cloud Build ansehen

Wenn Sie Cloud Build verwenden, können Sie Sicherheitslücken von Images auch in der Seitenleiste Security Insights in der Google Cloud Console ansehen.

Die Seitenleiste Sicherheitsinformationen bietet einen allgemeinen Überblick über die Sicherheitsinformationen für Builds von Artefakten, die in Artifact Registry gespeichert sind. Weitere Informationen zur Seitenleiste und dazu, wie Sie Cloud Build verwenden können, um Ihre Softwarelieferkette zu schützen, finden Sie unter Build-Sicherheitserkenntnisse ansehen.

Vorkommen filtern

Sie können Filterstrings in den gcloud-Befehlen und der Artifact Analysis API verwenden, um Vorkommen vor dem Abruf zu filtern. In den folgenden Abschnitten werden die unterstützten Suchfilter beschrieben.

Erkennungsvorkommen ansehen

Wenn Sie ein Image zum ersten Mal in Artifact Registry hochladen, wird ein Erkennungsvorkommen erstellt, das Informationen zum ersten Scan des Container-Images enthält.

Mit diesem Filterausdruck rufen Sie das Erkennungsvorkommen für ein Image ab:

kind="DISCOVERY" AND resourceUrl="RESOURCE_URL"

Dabei hat RESOURCE_URL das folgende Format:

LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

gcloud

Erkennungsvorkommen für ein Bild ansehen:

In diesem Fall wird der Ausdruck nicht direkt im Befehl verwendet. Stattdessen werden dieselben Informationen als Argumente übergeben:

Artifact Registry:

gcloud artifacts docker images list --show-occurrences \
--occurrence-filter='kind="DISCOVERY"' --format=json \
LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

API

Zum Abrufen des Erkennungsvorkommens muss Ihr Filterausdruck URL-codiert und so in eine GET-Anfrage eingebettet sein:

GET https://containeranalysis.googleapis.com/v1/projects/PROJECT_ID/occurrences?filter=kind%3D%22DISCOVERY%22%20AND%20resourceUrl%3D%22ENCODED_RESOURCE_URL%22

Weitere Informationen finden Sie unter dem API-Endpunkt projects.occurrences.get.

Java

import com.google.cloud.devtools.containeranalysis.v1.ContainerAnalysisClient;
import io.grafeas.v1.GrafeasClient;
import io.grafeas.v1.Occurrence;
import io.grafeas.v1.ProjectName;
import java.io.IOException;
import java.lang.InterruptedException;

public class GetDiscoveryInfo {
  // Retrieves and prints the Discovery Occurrence created for a specified image
  // The Discovery Occurrence contains information about the initial scan on the image
  public static void getDiscoveryInfo(String resourceUrl, String projectId) 
      throws IOException, InterruptedException {
    // String resourceUrl = "https://gcr.io/project/image@sha256:123";
    // String projectId = "my-project-id";
    String filterStr = "kind=\"DISCOVERY\" AND resourceUrl=\"" + resourceUrl + "\"";
    final String projectName = ProjectName.format(projectId);

    // Initialize client that will be used to send requests. After completing all of your requests, 
    // call the "close" method on the client to safely clean up any remaining background resources.
    GrafeasClient client = ContainerAnalysisClient.create().getGrafeasClient();
    for (Occurrence o : client.listOccurrences(projectName, filterStr).iterateAll()) {
      System.out.println(o);
    }
  }
}

Go


import (
	"context"
	"fmt"
	"io"

	containeranalysis "cloud.google.com/go/containeranalysis/apiv1"
	"google.golang.org/api/iterator"
	grafeaspb "google.golang.org/genproto/googleapis/grafeas/v1"
)

// getDiscoveryInfo retrieves and prints the Discovery Occurrence created for a specified image.
// The Discovery Occurrence contains information about the initial scan on the image.
func getDiscoveryInfo(w io.Writer, resourceURL, projectID string) error {
	// Use this style of URL when you use Google Container Registry.
	// resourceURL := "https://gcr.io/my-project/my-repo/my-image"
	// Use this style of URL when you use Google Artifact Registry.
	// resourceURL := "https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image"
	ctx := context.Background()
	client, err := containeranalysis.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	req := &grafeaspb.ListOccurrencesRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Filter: fmt.Sprintf(`kind="DISCOVERY" AND resourceUrl=%q`, resourceURL),
	}
	it := client.GetGrafeasClient().ListOccurrences(ctx, req)
	for {
		occ, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("occurrence iteration error: %w", err)
		}
		fmt.Fprintln(w, occ)
	}
	return nil
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample
 */
// const projectId = 'your-project-id', // Your GCP Project ID
// If you are using Google Container Registry
// const imageUrl = 'https://gcr.io/my-project/my-repo/my-image:123' // Image to attach metadata to
// If you are using Google Artifact Registry
// const imageUrl = 'https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image:123' // Image to attach metadata to

// Import the library and create a client
const {ContainerAnalysisClient} = require('@google-cloud/containeranalysis');
const client = new ContainerAnalysisClient();

const formattedParent = client.getGrafeasClient().projectPath(projectId);
// Retrieves and prints the Discovery Occurrence created for a specified image
// The Discovery Occurrence contains information about the initial scan on the image
const [occurrences] = await client.getGrafeasClient().listOccurrences({
  parent: formattedParent,
  filter: `kind = "DISCOVERY" AND resourceUrl = "${imageUrl}"`,
});

if (occurrences.length > 0) {
  console.log(`Discovery Occurrences for ${imageUrl}`);
  occurrences.forEach(occurrence => {
    console.log(`${occurrence.name}:`);
  });
} else {
  console.log('No occurrences found.');
}

Ruby

# resource_url = "The URL of the resource associated with the occurrence."
#                # e.g. https://gcr.io/project/image@sha256:123
# project_id   = "The Google Cloud project ID of the occurrences to retrieve"

require "google/cloud/container_analysis"

# Initialize the client
client = Google::Cloud::ContainerAnalysis.container_analysis.grafeas_client

parent = client.project_path project: project_id
filter = "kind = \"DISCOVERY\" AND resourceUrl = \"#{resource_url}\""
client.list_occurrences(parent: parent, filter: filter).each do |occurrence|
  # Process discovery occurrence here
  puts occurrence
end

Python

from google.cloud.devtools import containeranalysis_v1


def get_discovery_info(resource_url: str, project_id: str) -> None:
    """Retrieves and prints the discovery occurrence created for a specified
    image. The discovery occurrence contains information about the initial
    scan on the image."""
    # resource_url = 'https://gcr.io/my-project/my-image@sha256:123'
    # project_id = 'my-gcp-project'

    filter_str = f'kind="DISCOVERY" AND resourceUrl="{resource_url}"'
    client = containeranalysis_v1.ContainerAnalysisClient()
    grafeas_client = client.get_grafeas_client()
    project_name = f"projects/{project_id}"
    response = grafeas_client.list_occurrences(parent=project_name, filter_=filter_str)
    for occ in response:
        print(occ)

Vorkommen von Sicherheitslücken ansehen

Erstellen Sie eine Abfrage mit einem Filterausdruck, um Sicherheitslücken für ein bestimmtes Image aufzurufen:

kind="VULNERABILITY" AND resourceUrl="RESOURCE_URL"

Dabei hat RESOURCE_URL das folgende Format:

LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

gcloud

In diesem Fall wird der Ausdruck nicht direkt im Befehl verwendet. Stattdessen werden dieselben Informationen als Argumente übergeben:

Artifact Registry

gcloud artifacts docker images list --show-occurrences \
--occurrence-filter='kind="VULNERABILITY"' --format=json \
LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_ID

API

Die Ressourcen-URL muss URL-codiert und folgendermaßen in eine GET-Anfrage eingebettet sein:

GET https://containeranalysis.googleapis.com/v1/projects/PROJECT_ID/occurrences?filter=kind%3D%22VULNERABILITY%22%20AND%20resourceUrl%3D%22ENCODED_RESOURCE_URL%22

Weitere Informationen finden Sie unter dem API-Endpunkt projects.occurrences.get.

Java

import com.google.cloud.devtools.containeranalysis.v1.ContainerAnalysisClient;
import io.grafeas.v1.GrafeasClient;
import io.grafeas.v1.Occurrence;
import io.grafeas.v1.ProjectName;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;

public class VulnerabilityOccurrencesForImage {
  // Retrieve a list of vulnerability occurrences assoviated with a resource
  public static List<Occurrence> findVulnerabilityOccurrencesForImage(String resourceUrl, 
      String projectId) throws IOException {
    // String resourceUrl = "https://gcr.io/project/image@sha256:123";
    // String projectId = "my-project-id";
    final String projectName = ProjectName.format(projectId);
    String filterStr = String.format("kind=\"VULNERABILITY\" AND resourceUrl=\"%s\"", resourceUrl);

    // Initialize client that will be used to send requests. After completing all of your requests, 
    // call the "close" method on the client to safely clean up any remaining background resources.
    GrafeasClient client = ContainerAnalysisClient.create().getGrafeasClient();
    LinkedList<Occurrence> vulnerabilitylist = new LinkedList<Occurrence>();
    for (Occurrence o : client.listOccurrences(projectName, filterStr).iterateAll()) {
      vulnerabilitylist.add(o);
    }
    return vulnerabilitylist;
  }
}

Go


import (
	"context"
	"fmt"

	containeranalysis "cloud.google.com/go/containeranalysis/apiv1"
	"google.golang.org/api/iterator"
	grafeaspb "google.golang.org/genproto/googleapis/grafeas/v1"
)

// findVulnerabilityOccurrencesForImage retrieves all vulnerability Occurrences associated with a resource.
func findVulnerabilityOccurrencesForImage(resourceURL, projectID string) ([]*grafeaspb.Occurrence, error) {
	// Use this style of URL when you use Google Container Registry.
	// resourceURL := "https://gcr.io/my-project/my-repo/my-image"
	// Use this style of URL when you use Google Artifact Registry.
	// resourceURL := "https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image"
	ctx := context.Background()
	client, err := containeranalysis.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	req := &grafeaspb.ListOccurrencesRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Filter: fmt.Sprintf("resourceUrl = %q kind = %q", resourceURL, "VULNERABILITY"),
	}

	var occurrenceList []*grafeaspb.Occurrence
	it := client.GetGrafeasClient().ListOccurrences(ctx, req)
	for {
		occ, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return nil, fmt.Errorf("occurrence iteration error: %w", err)
		}
		occurrenceList = append(occurrenceList, occ)
	}

	return occurrenceList, nil
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample
 */
// const projectId = 'your-project-id', // Your GCP Project ID
// If you are using Google Container Registry
// const imageUrl = 'https://gcr.io/my-project/my-repo/my-image:123' // Image to attach metadata to
// If you are using Google Artifact Registry
// const imageUrl = 'https://LOCATION-docker.pkg.dev/my-project/my-repo/my-image:123' // Image to attach metadata to

// Import the library and create a client
const {ContainerAnalysisClient} = require('@google-cloud/containeranalysis');
const client = new ContainerAnalysisClient();

const formattedParent = client.getGrafeasClient().projectPath(projectId);

// Retrieve a list of vulnerability occurrences assoviated with a resource
const [occurrences] = await client.getGrafeasClient().listOccurrences({
  parent: formattedParent,
  filter: `kind = "VULNERABILITY" AND resourceUrl = "${imageUrl}"`,
});

if (occurrences.length) {
  console.log(`All Vulnerabilities for ${imageUrl}`);
  occurrences.forEach(occurrence => {
    console.log(`${occurrence.name}:`);
  });
} else {
  console.log('No occurrences found.');
}

Ruby

# resource_url = "The URL of the resource associated with the occurrence
#                e.g. https://gcr.io/project/image@sha256:123"
# project_id   = "The Google Cloud project ID of the vulnerabilities to find"

require "google/cloud/container_analysis"

# Initialize the client
client = Google::Cloud::ContainerAnalysis.container_analysis.grafeas_client

parent = client.project_path project: project_id
filter = "resourceUrl = \"#{resource_url}\" AND kind = \"VULNERABILITY\""
client.list_occurrences parent: parent, filter: filter

Python

from typing import List

from google.cloud.devtools import containeranalysis_v1
from grafeas.grafeas_v1 import types


def find_vulnerabilities_for_image(
    resource_url: str, project_id: str
) -> List[types.grafeas.Occurrence]:
    """ "Retrieves all vulnerability occurrences associated with a resource."""
    # resource_url = 'https://gcr.io/my-project/my-image@sha256:123'
    # project_id = 'my-gcp-project'

    client = containeranalysis_v1.ContainerAnalysisClient()
    grafeas_client = client.get_grafeas_client()
    project_name = f"projects/{project_id}"

    filter_str = 'kind="VULNERABILITY" AND resourceUrl="{}"'.format(resource_url)
    return list(grafeas_client.list_occurrences(parent=project_name, filter=filter_str))

Vorkommen eines bestimmten Typs aufrufen

In den beiden vorherigen Beispielen besteht der einzige Unterschied zwischen den Filterausdrücken im Wert von kind, der die Art des Vorkommens angibt. Mit diesem Feld können Sie die Liste der Vorkommen auf eine bestimmte Art beschränken, z. B. eine Sicherheitslücke oder Bereitstellung.

Verwenden Sie folgenden Filterausdruck, um Vorkommen für ein bestimmtes Image abzurufen:

kind="NOTE_KIND" AND resourceUrl="RESOURCE_URL"

Wobei:

NOTE_KIND ist die Art des Hinweises.
- Verwenden Sie beispielsweise DISCOVERY zum Auflisten der Erkennungsvorkommen. Erkennungsvorkommen werden für Images erstellt, wenn sie ursprünglich per Push-Befehl in Artifact Registry verschoben werden.
- Verwenden Sie zum Auflisten der Vorkommen von Sicherheitslücken die Art VULNERABILITY.
RESOURCE_URL ist die vollständige URL des Images https://HOSTNAME/PROJECT_ID/IMAGE_ID@sha256:HASH.

Der Filterausdruck zum Abrufen von Vorkommen einer bestimmten Art für mehrere Images lautet:

kind="NOTE_KIND" AND has_prefix(resourceUrl, "RESOURCE_URL_PREFIX")

Wobei:

RESOURCE_URL_PREFIX ist das URL-Präfix für einige Images.
- Zum Auflisten aller Versionen eines Images: https://HOSTNAME/PROJECT_ID/IMAGE_ID@
- Zum Auflisten aller Images in einem Projekt: https://HOSTNAME/PROJECT_ID/

Images aufrufen, die einem bestimmten Hinweis zugeordnet sind

Sie können eine Liste von Ressourcen abrufen, die einer bestimmten Hinweis-ID zugeordnet sind. So können Sie beispielsweise Images mit einer bestimmten CVE-Sicherheitslücke auflisten.

Verwenden Sie den folgenden Filterausdruck, um alle Images in einem Projekt aufzulisten, die einem bestimmten Hinweis zugeordnet sind:

noteProjectId="PROVIDER_PROJECT_ID" AND noteId="NOTE_ID"

Mit dem folgenden Filterausdruck können Sie ein bestimmtes Image auf einen konkreten Hinweis prüfen:

resourceUrl="RESOURCE_URL" AND noteProjectId="PROVIDER_PROJECT_ID" \
    AND noteId="NOTE_ID"

Wobei:

PROVIDER_PROJECT_ID ist die ID eines Provider-Projekts. Beispielsweise stellt goog-vulnz die Standardanalyse für Sicherheitslücken bereit.
NOTE_ID ist die ID des Hinweises. Sicherheitsrelevante Hinweise werden häufig als CVE-2019-12345 formatiert.
RESOURCE_URL ist die vollständige URL des Images https://HOSTNAME/PROJECT_ID/IMAGE_ID@sha256:HASH.

Mit dem folgenden Filterausdruck können Sie beispielsweise prüfen, ob alle Images gemäß der Google-Analyse CVE-2017-16231 enthalten:

noteProjectId="goog-vulnz" AND noteId="CVE-2017-16231"

Nächste Schritte

Pub/Sub-Benachrichtigungen verwenden, um Benachrichtigungen zu Sicherheitslücken und anderen Metadaten zu erhalten.
Mit Kritis Signer und Voucher können Sie Attestierungen für die Binärautorisierung als Teil Ihrer Build-Pipeline erstellen. Mit diesen Tools können Binärautorisierungs-Attestierungen auf der Grundlage von Ergebnissen von Sicherheitslücken-Scans erstellt werden. Weitere Informationen finden Sie unter Attestierungen mit Kritis Signer erstellen oder Attestierungen mit Voucher erstellen.