Usa la verificación de firma de Sigstore

En esta página, se muestra cómo usar la verificación de firmas de Sigstore de la validación continua (CV) de Autorización Binaria. La verificación comprueba las firmas generadas por Sigstore de las imágenes de contenedor asociadas con los Pods que se ejecutan en un clúster de Google Kubernetes Engine (GKE) en el que la CV está habilitada. La diferencia principal entre esta verificación y la verificación de certificación de firma simple es que el flujo de trabajo de firma de Sigstore no usa notas de Artifact Analysis para vincular firmas a las imágenes. Todas las firmas se almacenan junto a la imagen que firman.

Esta verificación solo admite repositorios de Artifact Registry.

Costos

En esta guía, se usan los siguientes servicios de Google Cloud:

  • Autorización Binaria, pero la CV está disponible de forma gratuita durante la etapa de vista previa
  • GKE
  • Cloud Key Management Service
  • Artifact Registry

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. Instala Google Cloud CLI.

  3. Para inicializar la CLI de gcloud, ejecuta el siguiente comando: 

    gcloud init

  4. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  5. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  6. Habilita las APIs de Binary Authorization, Cloud Key Management Service, Google Kubernetes Engine, Artifact Registry: 

    gcloud services enable binaryauthorization.googleapis.com cloudkms.googleapis.com container.googleapis.com artifactregistry.googleapis.com
    7.
  7. Instala Google Cloud CLI.

  8. Para inicializar la CLI de gcloud, ejecuta el siguiente comando: 

    gcloud init

  9. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  10. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  11. Habilita las APIs de Binary Authorization, Cloud Key Management Service, Google Kubernetes Engine, Artifact Registry: 

    gcloud services enable binaryauthorization.googleapis.com cloudkms.googleapis.com container.googleapis.com artifactregistry.googleapis.com
    12.
  12. Asegúrate de que gcloud CLI esté actualizada a la versión más reciente.
  13. Instala la herramienta de línea de comandos de kubectl.
  14. Si tus políticas de autorización binaria y clústeres de GKE están en proyectos diferentes, asegúrate de que la autorización binaria esté habilitada en ambos proyectos.
  15. Instala la herramienta de línea de comandos de cosign.

Roles obligatorios

En esta sección, se muestra cómo configurar las funciones para esta verificación.

Descripción general

Si ejecutas todos los productos mencionados en esta guía en el mismo proyecto, no necesitas establecer ningún permiso. La autorización binaria configura las funciones de forma correcta cuando la habilitas. Si ejecutas los productos en diferentes proyectos, debes establecer las funciones como se describe en esta sección.

Para garantizar que el agente de servicio de Autorización Binaria de cada proyecto tenga los permisos necesarios para evaluar la verificación de firmas de Sigstore de la CV, pídele a tu administrador que otorgue al agente de servicio de Autorización Binaria en cada proyecto los siguientes roles de IAM:

  • Si tu proyecto de clúster es diferente del proyecto de política: Evaluador de política de Autorización Binaria (roles/binaryauthorization.policyEvaluator) en el agente de servicio de Autorización Binaria del proyecto del clúster
  • Si tu proyecto de repositorio de imágenes es diferente del proyecto de política: Lector de Artifact Registry (roles/artifactregistry.reader) en el agente de servicio de Autorización Binaria del proyecto de política

Si quieres obtener más información para otorgar roles, consulta Administra el acceso.

Es posible que tu administrador también pueda otorgar al agente de servicio de Autorización Binaria en cada proyecto los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Otorga roles mediante gcloud CLI

Para garantizar que el agente de servicio de autorización binaria de cada proyecto tenga los permisos necesarios para evaluar la verificación de firmas de Sigstore de la CV, otorga al agente de servicio de Autorización Binaria en cada proyecto los siguientes roles de IAM:

  1. Otorga permiso al agente de servicio de Autorización Binaria del proyecto del clúster para acceder a la política en el proyecto de política.

    1. Obtén el agente de servicio de Autorización Binaria del proyecto de clúster:

      PROJECT_NUMBER=$(gcloud projects list --filter="projectId:CLUSTER_PROJECT_ID" \
  --format="value(PROJECT_NUMBER)")
CLUSTER_SERVICE_ACCOUNT="service-$PROJECT_NUMBER@gcp-sa-binaryauthorization.iam.gserviceaccount.com"

      Reemplaza CLUSTER_PROJECT_ID por el ID del proyecto del clúster.

    2. Permite que la CV evalúe la política en el clúster:

      gcloud projects add-iam-policy-binding POLICY_PROJECT_ID \
    --member="serviceAccount:$CLUSTER_SERVICE_ACCOUNT" \
    --role='roles/binaryauthorization.policyEvaluator'

      Reemplaza POLICY_PROJECT_ID por el ID del proyecto que contiene tu política.

  2. Permite que el agente de servicio de autorización binaria del proyecto de política acceda a las firmas de tu repositorio:

    1. Obtén el agente de servicio de Autorización Binaria del proyecto de política:

      PROJECT_NUMBER=$(gcloud projects list \
  --filter="projectId:POLICY_PROJECT_ID" \
  --format="value(PROJECT_NUMBER)")
SERVICE_ACCOUNT="service-$PROJECT_NUMBER@gcp-sa-binaryauthorization.iam.gserviceaccount.com"

      Reemplaza POLICY_PROJECT_ID por el ID del proyecto que contiene tu política.

    2. Otorga el rol:

      gcloud projects add-iam-policy-binding REPOSITORY_PROJECT_ID \
    --member="serviceAccount:$SERVICE_ACCOUNT" \
    --role='roles/artifactregistry.reader'

      Reemplaza REPOSITORY_PROJECT_ID por el ID del proyecto que contiene tu repositorio.

Crea un par de claves

En esta sección, crearás un par de claves asimétricas: Algoritmo de firma digital de curva elíptica (ECDSA).

Usa la clave privada a fin de firmar la imagen, lo que crea la certificación. Incluirás la clave pública en la política de la plataforma. Cuando la CV verifica la certificación, usa la clave pública para verificarla.

Puedes usar Cloud Key Management Service (Cloud KMS) o claves locales, pero te recomendamos usar claves de Cloud KMS para la producción.

Cofirma de PKIX para Cloud KMS

  1. Configura las variables de entorno necesarias para crear el par de claves. Para ello, te recomendamos que completes los marcadores de posición en el siguiente comando y, luego, ejecutes el comando.

    KMS_KEY_PROJECT_ID=KMS_KEY_PROJECT_ID
KMS_KEYRING_NAME=KMS_KEYRING_NAME
KMS_KEY_NAME=KMS_KEY_NAME
KMS_KEY_LOCATION=global
KMS_KEY_PURPOSE=asymmetric-signing
KMS_KEY_ALGORITHM=ec-sign-p256-sha256
KMS_PROTECTION_LEVEL=software
KMS_KEY_VERSION=1

    Reemplaza lo siguiente:

    • KMS_KEY_PROJECT_ID: el ID de tu proyecto
    • KMS_KEYRING_NAME: un nombre para el llavero de claves de Cloud KMS
    • KMS_KEY_NAME: un nombre para tu clave de Cloud KMS

  2. Genera la clave con la CLI de Cosign:

    cosign generate-key-pair \
  --kms gcpkms://projects/${KMS_KEY_PROJECT_ID}/locations/${KMS_KEY_LOCATION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME}

  3. Registra la ubicación de la clave pública:

    Cofirma guarda de forma automática la clave pública generada como cosign.pub en el directorio en el que se ejecutó el comando generate-key-pair. Guarda esta ubicación del archivo en una variable para comandos futuros.

    PUBLIC_KEY_FILE="$(pwd)/cosign.pub"

gcloud de PKIX para Cloud KMS

Para crear el par de claves en Cloud KMS, haz lo siguiente:

  1. Configura las variables de entorno necesarias para crear el par de claves. Para ello, te recomendamos que completes los marcadores de posición en el siguiente comando y, luego, ejecutes el comando.

    KMS_KEY_PROJECT_ID=KMS_KEY_PROJECT_ID
KMS_KEYRING_NAME=KMS_KEYRING_NAME
KMS_KEY_NAME=KMS_KEY_NAME
KMS_KEY_LOCATION=global
KMS_KEY_PURPOSE=asymmetric-signing
KMS_KEY_ALGORITHM=ec-sign-p256-sha256
KMS_PROTECTION_LEVEL=software
KMS_KEY_VERSION=1

    Reemplaza lo siguiente:

    • KMS_KEY_PROJECT_ID: el ID de tu proyecto
    • KMS_KEYRING_NAME: un nombre para el llavero de claves de Cloud KMS
    • KMS_KEY_NAME: un nombre para tu clave de Cloud KMS

  2. Crea el llavero de claves:

    gcloud kms keyrings create ${KMS_KEYRING_NAME} \
    --location=${KMS_KEY_LOCATION} \
    --project=${KMS_KEY_PROJECT_ID}

  3. Crea la clave:

    gcloud kms keys create ${KMS_KEY_NAME} \
    --location=${KMS_KEY_LOCATION} \
    --keyring=${KMS_KEYRING_NAME}  \
    --purpose=${KMS_KEY_PURPOSE} \
    --default-algorithm=${KMS_KEY_ALGORITHM} \
    --protection-level=${KMS_PROTECTION_LEVEL} \
    --project=${KMS_KEY_PROJECT_ID}

  4. Exporta el material de la clave pública a un archivo:

    PUBLIC_KEY_FILE="$(pwd)/cosign.pub"
gcloud kms keys versions get-public-key 1 \
    --key=${KMS_KEY_NAME} \
    --keyring=${KMS_KEYRING_NAME} \
    --location=${KMS_KEY_LOCATION} \
    --output-file=${PUBLIC_KEY_FILE} \
    --project=${KMS_KEY_PROJECT_ID}

Clave local

Para crear el par de claves de forma local, haz lo siguiente:

  cosign generate-key-pair
  PUBLIC_KEY_FILE="$(pwd)/cosign.pub"
  PRIVATE_KEY_FILE="$(pwd)/cosign.key"

Crea la política de la plataforma

Para crear la política de plataforma de la CV con una verificación de firma de Sigstore, haz lo siguiente:

  1. Crea el archivo de política de plataforma de verificación de firma de Sigstore:

    cat > POLICY_PATH <<EOF
gkePolicy:
  checkSets:
  - checks:
    - displayName: sigstore-signature-check
      sigstoreSignatureCheck:
        sigstoreAuthorities:
        - displayName: sigstore-authority
          publicKeySet:
            publicKeys:
              publicKeyPem: |
$(awk '{printf "                %s\n", $0}' ${PUBLIC_KEY_FILE})
EOF

    Reemplaza POLICY_PATH por la ruta de acceso al archivo de política.

  2. Crea la política de plataforma:

    Antes de usar cualquiera de los datos de comando a continuación, haz los siguientes reemplazos:

    • POLICY_ID: un ID de la política de plataforma que elijas. Si la política se encuentra en otro proyecto, puedes usar el nombre completo del recurso: projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID.
    • POLICY_PATH: una ruta de acceso al archivo de política.
    • POLICY_PROJECT_ID: el ID del proyecto de políticas.

    Ejecuta el siguiente comando:

    Linux, macOS o Cloud Shell

    gcloud beta container binauthz policy create POLICY_ID \
    --platform=gke \
    --policy-file=POLICY_PATH \
    --project=POLICY_PROJECT_ID

    Windows (PowerShell)

    gcloud beta container binauthz policy create POLICY_ID `
    --platform=gke `
    --policy-file=POLICY_PATH `
    --project=POLICY_PROJECT_ID

    Windows (cmd.exe)

    gcloud beta container binauthz policy create POLICY_ID ^
    --platform=gke ^
    --policy-file=POLICY_PATH ^
    --project=POLICY_PROJECT_ID

Habilita la CV

Puedes crear un clúster nuevo o actualizar uno existente para usar la supervisión de la CV con políticas de plataforma basadas en verificaciones.

Crea un clúster que use la supervisión de la CV

En esta sección, crearás un clúster que solo usará la supervisión de la CV con las políticas de plataforma basadas en verificaciones.

Antes de usar cualquiera de los datos de comando a continuación, haz los siguientes reemplazos:

  • CLUSTER_NAME: un nombre de clúster.
  • LOCATION: la ubicación, por ejemplo, us-central1 o asia-south1.
  • POLICY_PROJECT_ID: El ID del proyecto en el que se almacena la política.
  • POLICY_ID: El ID de la política.
  • CLUSTER_PROJECT_ID: el ID del proyecto del clúster.

Ejecuta el siguiente comando:

Linux, macOS o Cloud Shell

gcloud beta container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --binauthz-evaluation-mode=POLICY_BINDINGS \
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \
    --project=CLUSTER_PROJECT_ID

Windows (PowerShell)

gcloud beta container clusters create CLUSTER_NAME `
    --location=LOCATION `
    --binauthz-evaluation-mode=POLICY_BINDINGS `
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID `
    --project=CLUSTER_PROJECT_ID

Windows (cmd.exe)

gcloud beta container clusters create CLUSTER_NAME ^
    --location=LOCATION ^
    --binauthz-evaluation-mode=POLICY_BINDINGS ^
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^
    --project=CLUSTER_PROJECT_ID

Crea un clúster que use la aplicación y la supervisión de la CV

En esta sección, crearás un clúster que use la aplicación de políticas singleton de proyecto con la supervisión de la CV con políticas de plataforma basadas en verificaciones:

Antes de usar cualquiera de los datos de comando a continuación, haz los siguientes reemplazos:

  • CLUSTER_NAME: un nombre de clúster.
  • LOCATION: la ubicación, por ejemplo, us-central1 o asia-south1.
  • POLICY_PROJECT_ID: El ID del proyecto en el que se almacena la política.
  • POLICY_ID: El ID de la política.
  • CLUSTER_PROJECT_ID: el ID del proyecto del clúster.

Ejecuta el siguiente comando:

Linux, macOS o Cloud Shell

gcloud beta container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE \
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \
    --project=CLUSTER_PROJECT_ID

Windows (PowerShell)

gcloud beta container clusters create CLUSTER_NAME `
    --location=LOCATION `
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE `
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID `
    --project=CLUSTER_PROJECT_ID

Windows (cmd.exe)

gcloud beta container clusters create CLUSTER_NAME ^
    --location=LOCATION ^
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE ^
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^
    --project=CLUSTER_PROJECT_ID

Actualiza un clúster para usar la supervisión de la CV

En esta sección, actualizarás un clúster para usar la supervisión de la CV solo con las políticas de plataforma basadas en verificaciones. Si el clúster ya tiene la aplicación de la política de singleton de proyecto habilitada, la ejecución de este comando la inhabilita. En su lugar, considera actualizar el clúster con la aplicación y la supervisión de la CV habilitadas.

Antes de usar cualquiera de los datos de comando a continuación, haz los siguientes reemplazos:

  • CLUSTER_NAME: el nombre del clúster
  • LOCATION: la ubicación, por ejemplo: us-central1 o asia-south1
  • POLICY_PROJECT_ID: el ID del proyecto en el que se almacena la política
  • POLICY_ID: el ID de la política
  • CLUSTER_PROJECT_ID: Es el ID del proyecto del clúster

Ejecuta el siguiente comando:

Linux, macOS o Cloud Shell

gcloud beta container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --binauthz-evaluation-mode=POLICY_BINDINGS \
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \
    --project=CLUSTER_PROJECT_ID

Windows (PowerShell)

gcloud beta container clusters update CLUSTER_NAME `
    --location=LOCATION `
    --binauthz-evaluation-mode=POLICY_BINDINGS `
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID `
    --project=CLUSTER_PROJECT_ID

Windows (cmd.exe)

gcloud beta container clusters update CLUSTER_NAME ^
    --location=LOCATION ^
    --binauthz-evaluation-mode=POLICY_BINDINGS ^
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^
    --project=CLUSTER_PROJECT_ID

Actualiza un clúster para usar la aplicación y la supervisión de la CV

En esta sección, actualizarás un clúster para usar la aplicación de políticas de singleton del proyecto y la supervisión de la CV con políticas de plataforma basadas en verificaciones.

Antes de usar cualquiera de los datos de comando a continuación, haz los siguientes reemplazos:

  • CLUSTER_NAME: un nombre de clúster
  • LOCATION: la ubicación, por ejemplo: us-central1 o asia-south1
  • POLICY_PROJECT_ID: el ID del proyecto en el que se almacena la política
  • POLICY_ID: el ID de la política
  • CLUSTER_PROJECT_ID: Es el ID del proyecto del clúster

Ejecuta el siguiente comando:

Linux, macOS o Cloud Shell

gcloud beta container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE \
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \
    --project=CLUSTER_PROJECT_ID

Windows (PowerShell)

gcloud beta container clusters update CLUSTER_NAME `
    --location=LOCATION `
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE `
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID `
    --project=CLUSTER_PROJECT_ID

Windows (cmd.exe)

gcloud beta container clusters update CLUSTER_NAME ^
    --location=LOCATION ^
    --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE ^
    --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^
    --project=CLUSTER_PROJECT_ID

Prueba la CV

En esta sección, probarás la CV a través de la implementación de una imagen firmada. En este caso, la verificación de firma de la CV Sigstore verifica la firma y no produce entradas de registro.

Luego, intentarás implementar una imagen sin firma diferente. En este caso, la verificación de CV no puede encontrar una firma válida y registra la infracción en Cloud Logging.

Firma una imagen

Para satisfacer la verificación, la imagen necesita una firma válida. Para crear la firma, haz lo siguiente:

  1. Crea las variables que usas para firmar la imagen:

    IMAGE_PATH=IMAGE_PATH
IMAGE_DIGEST=sha256:IMAGE_DIGEST_SHA
IMAGE_TO_SIGN="${IMAGE_PATH}@${IMAGE_DIGEST}"

    Reemplaza lo siguiente:

    • IMAGE_PATH: Es la ruta de acceso a tu imagen
    • IMAGE_DIGEST_SHA: Es el hash SHA del resumen de la imagen.

  2. Firma la imagen y envía la firma a Artifact Registry:

    PKIX (Cloud KMS)

    Firma la imagen con una clave alojada en Cloud KMS y envía la firma a Artifact Registry:

    cosign sign \
    --key gcpkms://projects/${KMS_KEY_PROJECT_ID}/locations/${KMS_KEY_LOCATION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME} \
    ${IMAGE_TO_SIGN}

    Clave local

    Firma la imagen con una clave privada local y envía la firma a Artifact Registry.

    cosign sign --key ${PRIVATE_KEY_FILE} ${IMAGE_TO_SIGN}

  3. Responde al mensaje de Cofirma:

    Después de ejecutar el comando cosign sign, Cofirma te preguntará si quieres subir la firma al Rekor del registro de transparencia. Responde y o n a los mensajes. Para obtener más información sobre Rekor, consulta la documentación de Rekor.

Verifica la firma de forma manual

Para verificar la firma de forma manual, haz lo siguiente:

  1. Asegúrate de que la firma exista en Artifact Registry:

    Consola de Google Cloud

    1. Ve a la página de Artifact Registry en la consola de Google Cloud.

      Ir a Artifact Registry

    2. En la lista de repositorios, haz clic en el nombre del repositorio que contiene tu imagen.

    3. Haz clic en el nombre de la imagen que firmaste.

    4. Ubica el elemento que contiene la firma. Este elemento tiene la etiqueta sha256-[image digest].sig. Debe haber solo un elemento con la etiqueta.

    5. Haz clic en Manifiesto.

    6. Deberías ver un archivo con formato JSON con varios campos. Cada firma reside en un elemento de la lista layers, en el mapa annotations. Las firmas se encuentran en la clave dev.cosignproject.cosign/signature.

      El siguiente es un manifiesto de ejemplo:

      {
        "schemaVersion": 2,
        "mediaType": "application/vnd.oci.image.manifest.v1+json",
        "config": {
            "mediaType": "application/vnd.oci.image.config.v1+json",
            "size": SIZE_OF_LAYERS,
            "digest": "DIGEST_OF_LAYERS"
        },
        "layers": [
            {
                "mediaType": "application/vnd.dev.cosign.simplesigning.v1+json",
                "size": SIZE_OF_ANNOTATIONS,
                "digest": "DIGEST_OF_ANNOTATIONS",
                "annotations": {
                    "dev.cosignproject.cosign/signature": "BASE64_SIGNATURE",
                    "dev.sigstore.cosign/bundle": "BUNDLE"
                }
            }
        ]
  }

    El manifiesto de ejemplo incluye lo siguiente:

    • SIZE_OF_LAYERS: Es el tamaño del array layers en bytes
    • DIGEST_OF_LAYERS: Es el resumen del array layers
    • SIZE_OF_ANNOTATIONS: Es el tamaño del diccionario de annotations en bytes
    • DIGEST_OF_ANNOTATIONS: Es el resumen del diccionario de annotations
    • BASE64_SIGNATURE: Es la firma sin procesar codificada en formato base64. Esta es la firma que se usará para la verificación
    • BUNDLE: Son los metadatos específicos de Sigstore

    Puedes encontrar más detalles sobre el formato del manifiesto en la especificación de la firma de cofirma de Sigstore.

    Línea de comandos

    1. Busca el artefacto correcto:

      Haz una lista de los elementos almacenados con la imagen:

      gcloud artifacts docker tags list ${IMAGE_PATH}

      Un resultado de ejemplo se ve de la siguiente manera:

      Listing items under project PROJECT_ID, location REPOSITORY_LOCATION, repository REPOSITORY_NAME.
TAG                         IMAGE                                                         DIGEST
latest                      us-east1-docker.pkg.dev/my-project/my-repo/my-image           sha256:abc123
sha256-abc123.sig           us-east1-docker.pkg.dev/my-project/my-repo/my-image           sha256:def456

      En el resultado, el artefacto con la etiqueta sha256-abc123.sig contiene la firma en su manifiesto.

    2. Obtén el manifiesto

      Para obtener el manifiesto del artefacto con la etiqueta sha256-IMAGE_DIGEST_SHA.sig, ejecuta el siguiente comando:

      curl -X GET -H "Content-Type: application/json" \
            -H "Authorization: Bearer $(gcloud auth print-access-token)" \
            -H "X-Goog-User-Project: REPOSITORY_PROJECT_ID" \
            "https://REPOSITORY_LOCATION-docker.pkg.dev/v2/REPOSITORY_PROJECT_ID/REPOSITORY_NAME/IMAGE_NAME/manifests/sha256-IMAGE_DIGEST_SHA.sig"

      Reemplaza lo siguiente:

      • REPOSITORY_PROJECT_ID: Es el ID del proyecto que contiene el repositorio
      • REPOSITORY_LOCATION: Es la ubicación del repositorio
      • REPOSITORY_NAME: Es el nombre del repositorio
      • IMAGE_NAME: Es el nombre de la imagen

      Deberías ver un archivo con formato JSON con varios campos. Cada firma reside en un elemento de la lista layers, en el mapa annotations. Las firmas se encuentran en la clave dev.cosignproject.cosign/signature.

      A continuación, se muestra un ejemplo del manifiesto:

      {
    "schemaVersion": 2,
    "mediaType": "application/vnd.oci.image.manifest.v1+json",
    "config": {
        "mediaType": "application/vnd.oci.image.config.v1+json",
        "size": SIZE_OF_LAYERS,
        "digest": "DIGEST_OF_LAYERS"
    },
    "layers": [
        {
            "mediaType": "application/vnd.dev.cosign.simplesigning.v1+json",
            "size": SIZE_OF_ANNOTATIONS,
            "digest": "DIGEST_OF_ANNOTATIONS",
            "annotations": {
                "dev.cosignproject.cosign/signature": "BASE64_SIGNATURE",
                "dev.sigstore.cosign/bundle": "BUNDLE"
            }
        }
    ]
}

    El manifiesto de ejemplo incluye lo siguiente:

    • SIZE_OF_LAYERS: Es el tamaño del array layers en bytes
    • DIGEST_OF_LAYERS: Es el resumen del array layers
    • SIZE_OF_ANNOTATIONS: Es el tamaño del diccionario de annotations en bytes
    • DIGEST_OF_ANNOTATIONS: Es el resumen del diccionario de annotations
    • BASE64_SIGNATURE: Es la firma sin procesar codificada en formato base64. Esta es la firma que se usará para la verificación
    • BUNDLE: Son los metadatos específicos de Sigstore

    Puedes encontrar más detalles sobre el formato del manifiesto en la especificación de la firma de cofirma de Sigstore.

  2. Verifica la firma de forma manual:

    Usa cosign verify para verificar la firma que se subió:

    PKIX (Cloud KMS) 

    cosign verify --key gcpkms://projects/${KMS_KEY_PROJECT_ID}/locations/${KMS_KEY_LOCATION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME} \
      ${IMAGE_PATH}@${IMAGE_DIGEST}

    Clave local 

    cosign verify --key {PUBLIC_KEY_FILE} ${IMAGE_PATH}@${IMAGE_DIGEST}

    El resultado del comando indica que The signatures were verified against the specified public key si la verificación se realizó de forma correcta.

Implementa la imagen firmada

Para implementar una imagen firmada, haz lo siguiente:

  1. Configura kubectl:

    gcloud container clusters get-credentials CLUSTER_NAME \
    --location=LOCATION \
    --project=CLUSTER_PROJECT_ID

    Reemplaza lo siguiente:

    • CLUSTER_NAME: es el nombre de tu clúster
    • LOCATION: es la ubicación del clúster
    • CLUSTER_PROJECT_ID: Es el ID del proyecto del clúster

  2. Implementa una imagen y verifica la implementación con la política de Autorización Binaria:

    kubectl run hello-app-signed --image=${IMAGE_PATH}@${IMAGE_DIGEST}

    Se implementó el Pod. Debido a que la imagen está firmada, la CV no produce entradas de registro relacionadas con este Pod.

Implementa una imagen sin firma

En esta sección, implementarás una imagen sin firma.

Debido a que la política requiere firmas y esta imagen no tiene una, la CV registra con regularidad la infracción mientras se ejecuta el contenedor.

Para implementar la imagen, ejecuta el siguiente comando.

  kubectl run hello-app-unsigned \
      --image=UNSIGNED_IMAGE_PATH@UNSIGNED_IMAGE_DIGEST

Se implementó el Pod. Debido a que la imagen no tiene una certificación, la CV produce entradas de registro mientras se ejecuta el Pod.

Visualiza los registros de entradas de la CV

Con la CV, se registran los incumplimientos de políticas de la plataforma en Cloud Logging en 24 horas. Por lo general, puedes ver las entradas en un par de horas.

Si ninguna imagen infringe las políticas de la plataforma que habilitaste, no aparecerán las entradas en los registros.

Para ver las entradas de registro de CV de los últimos siete días, ejecuta el siguiente comando:

gcloud logging read \
     --order="desc" \
     --freshness=7d \
     --project=CLUSTER_PROJECT_ID \
    'logName:"binaryauthorization.googleapis.com%2Fcontinuous_validation" "policyName"'

Reemplaza CLUSTER_PROJECT_ID por el ID del proyecto del clúster.

Tipos de verificación

Los registros de la CV verifican la información de incumplimiento en checkResults. En la entrada, el valor checkType indica la verificación. Los valores para cada verificación son los siguientes:

  • ImageFreshnessCheck
  • SigstoreSignatureCheck
  • SimpleSigningAttestationCheck
  • SlsaCheck
  • TrustedDirectoryCheck
  • VulnerabilityCheck

Registro de ejemplo

En el siguiente ejemplo de entrada de Logging de la CV, se describe una imagen que no infringe una verificación de directorio de confianza:

{
  "insertId": "637c2de7-0000-2b64-b671-24058876bb74",
  "jsonPayload": {
    "podEvent": {
      "endTime": "2022-11-22T01:14:30.430151Z",
      "policyName": "projects/123456789/platforms/gke/policies/my-policy",
      "images": [
        {
          "result": "DENY",
          "checkResults": [
            {
              "explanation": "TrustedDirectoryCheck at index 0 with display name \"My trusted directory check\" has verdict NOT_CONFORMANT. Image is not in a trusted directory",
              "checkSetName": "My check set",
              "checkSetIndex": "0",
              "checkName": "My trusted directory check",
              "verdict": "NON_CONFORMANT",
              "checkType": "TrustedDirectoryCheck",
              "checkIndex": "0"
            }
          ],
          "image": "gcr.io/my-project/hello-app:latest"
        }
      ],
      "verdict": "VIOLATES_POLICY",
      "podNamespace": "default",
      "deployTime": "2022-11-22T01:06:53Z",
      "pod": "hello-app"
    },
    "@type": "type.googleapis.com/google.cloud.binaryauthorization.v1beta1.ContinuousValidationEvent"
  },
  "resource": {
    "type": "k8s_cluster",
    "labels": {
      "project_id": "my-project",
      "location": "us-central1-a",
      "cluster_name": "my-test-cluster"
    }
  },
  "timestamp": "2022-11-22T01:44:28.729881832Z",
  "severity": "WARNING",
  "logName": "projects/my-project/logs/binaryauthorization.googleapis.com%2Fcontinuous_validation",
  "receiveTimestamp": "2022-11-22T03:35:47.171905337Z"
}

Limpia

En esta sección, se describe cómo limpiar la supervisión de la CV que configuraste antes en esta guía.

Puedes inhabilitar la supervisión de la CV o Autorización Binaria y la CV en tu clúster.

Inhabilita Autorización Binaria en un clúster

Para inhabilitar la aplicación de CV y de Autorización Binaria en tu clúster, ejecuta el siguiente comando:

gcloud beta container clusters update CLUSTER_NAME \
    --binauthz-evaluation-mode=DISABLED \
    --location=LOCATION \
    --project=CLUSTER_PROJECT_ID

Reemplaza lo siguiente:

  • CLUSTER_NAME: es el nombre del clúster
  • LOCATION: es la ubicación del clúster
  • CLUSTER_PROJECT_ID: Es el ID del proyecto del clúster

Inhabilita la supervisión de políticas basada en verificaciones en un clúster

Para inhabilitar la CV con políticas basadas en verificaciones en el clúster y volver a habilitar la aplicación mediante la política de aplicación de Autorización Binaria, ejecuta el siguiente comando:

gcloud beta container clusters update CLUSTER_NAME  \
    --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \
    --location=LOCATION \
    --project="CLUSTER_PROJECT_ID"

Reemplaza lo siguiente:

  • CLUSTER_NAME: es el nombre del clúster
  • LOCATION: es la ubicación del clúster
  • CLUSTER_PROJECT_ID: Es el ID del proyecto del clúster

Ten en cuenta que --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE es equivalente a la marca --enable-binauthz anterior.

Borrar la política

Para borrar la política, ejecuta el siguiente comando. No es necesario borrar la política de plataforma basada en verificaciones para inhabilitar la auditoría de políticas basada en verificaciones.

gcloud beta container binauthz policy delete POLICY_ID \
    --platform=gke \
    --project="POLICY_PROJECT_ID"

Reemplaza lo siguiente:

  • POLICY_ID: el ID de la política
  • POLICY_PROJECT_ID: el ID del proyecto de política

¿Qué sigue?