Créer des certificateurs à l'aide de Cloud Console

Cette page explique comment créer un certificateur dans l'autorisation binaire à l'aide de Google Cloud Console. Vous pouvez également effectuer ces étapes à l'aide de l'outil de ligne de commande gcloud ou de l'API REST. Cette tâche fait partie de la configuration de l'autorisation binaire.

Avant de commencer

Avant de créer des certificateurs, procédez comme suit :

  1. L'autorisation binaire doit être activée. Pour en savoir plus, consultez la page Activer l'autorisation binaire.

  2. La stratégie doit être configurée de manière à n'autoriser que les images validées par des certificateurs. Pour en savoir plus, consultez la page Configurer une stratégie à l'aide de la console.

Présentation

Un certificateur est une ressource GCP utilisée par l'autorisation binaire pour valider une attestation. Pour en savoir plus sur l'autorisation binaire, consultez la page Présentation de l'autorisation binaire.

Pour créer un certificateur, vous devez effectuer les actions suivantes :

  • Configurer une paire de clés PKIX pouvant être utilisées pour vérifier l'identité du certificateur. (Les paires de clés asymétriques générées par Cloud Key Management Service (Cloud KMS) sont dans un format compatible avec PKIX.)
  • Créer le certificateur proprement dit dans l'autorisation binaire, puis lui associer la clé publique que vous avez créée.

Dans une configuration à un seul projet, vous créez votre certificateur dans le projet au sein duquel vous configurez votre stratégie d'autorisation binaire. Dans une configuration multiprojets, vous avez probablement un projet déployant hébergeant la configuration de votre stratégie et un projet certifiant distinct hébergeant vos certificateurs.

Configurer des clés cryptographiques

L'autorisation binaire vous permet d'utiliser des clés PKIX pour vérifier l'identité des certificateurs de manière sécurisée. Ainsi, seules les parties validées peuvent autoriser une image de conteneur.

Dans ce guide, l'algorithme de signature numérique à courbe elliptique (ECDSA) recommandé est utilisé pour générer une paire de clés PKIX. Vous pouvez également utiliser des clés RSA ou PGP pour la signature. Consultez la page Objectifs et algorithmes des clés pour plus d'informations sur les algorithmes de signature.

Créer une paire de clés PKIX

L'autorisation binaire vous permet d'utiliser des paires de clés PKIX asymétriques pour vérifier l'identité d'un certificateur. La paire de clés se compose d'une clé privée, utilisée par le certificateur pour signer numériquement les attestations, et d'une clé publique que vous ajoutez au certificateur telle qu'elle est stockée par le service d'autorisation binaire.

Une paire de clés PKIX consiste en une clé privée, que le signataire utilise pour signer numériquement des attestations, et une clé publique que vous ajoutez au certificateur. Au moment du déploiement, l'autorisation binaire utilise cette clé publique pour vérifier l'attestation signée par la clé privée.

Les paires de clés asymétriques générées et stockées dans Cloud KMS sont compatibles avec le format PKIX. Pour créer une clé Cloud KMS à utiliser avec l'autorisation binaire, consultez la page Créer des clés asymétriques. Veillez à choisir l'option Signature asymétrique comme objectif de clé lors de la création de celle-ci.

PKIX (clé locale)

Pour générer une paire de clés PKIX asymétrique locale et la stocker dans un fichier, procédez comme suit :

  1. Générez la clé :

    PRIVATE_KEY_FILE="/tmp/ec_private.pem"
    openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}
    
  2. Comme ce fichier contient à la fois une clé publique et une clé privée, vous devez extraire la clé publique vers un fichier distinct afin de pouvoir l'ajouter au certificateur :

    PUBLIC_KEY_FILE="/tmp/ec_public.pem"
    openssl ec -in ${PRIVATE_KEY_FILE} -pubout -out ${PUBLIC_KEY_FILE}
    

PKIX (Cloud KMS)

Pour créer la paire de clés dans Cloud KMS, procédez comme suit :

  1. Configurez les variables d'environnement nécessaires à la création de la paire de clés.

    KMS_KEY_PROJECT_ID=${PROJECT_ID}
    KMS_KEYRING_NAME=my-binauthz-keyring
    KMS_KEY_NAME=my-binauthz-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
    
  2. Créez le trousseau de clés.

    gcloud kms keyrings create ${KMS_KEYRING_NAME} \
      --location ${KMS_KEY_LOCATION}
    
  3. Créez la clé :

    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}
    

Créer le certificateur

L'étape suivante consiste à créer le certificateur proprement dit et à lui associer une note Container Analysis et une clé publique.

L'autorisation binaire utilise Container Analysis pour stocker les métadonnées de confiance utilisées dans le processus d'autorisation. Pour chaque certificateur que vous créez, vous devez créer une note Container Analysis. Chaque attestation est stockée en tant qu'occurrence de cette note.

Pour créer le certificateur, procédez comme suit :

  1. Accédez à la page "Binary Authorization" (Autorisation binaire) du projet certifiant.

    Accéder à la page "Autorisation binaire"

  2. Dans l'onglet Attestors (Certificateurs), cliquez sur Create (Créer).

  3. Cliquez sur Create New Attestor (Créer un certificateur).

  4. Dans le champ Attestor Name (Nom du certificateur), saisissez le nom du certificateur (par exemple, build-secure ou prod-qa).

  5. Sélectionnez l'option Automatically Generate a Container Analysis Note (Générer automatiquement une note Container Analysis) pour créer une note.

    Si vous souhaitez utiliser une note existante que vous avez précédemment créée, décochez cette option et saisissez le nom complet de votre note dans le champ ID de note Container Analysis). Le nom suit le format projects/PROJECT_ID/notes/NOTE_ID.

  6. Ajoutez la clé publique au certificateur :

    PKIX (clé locale)

    1. Cliquez sur Add a PKIX Key (Ajouter une clé PKIX).
    2. Cliquez sur Importer depuis un fichier.
    3. Accédez au fichier de clé PKIX que vous avez enregistré précédemment et sélectionnez-le. Remarque : Vous pouvez également coller une clé publique au format PEM.
    4. Sélectionnez l'algorithme de signature. L'exemple de clé de ce guide est généré à l'aide de l'algorithme Elliptic Curve P256 - SHA Digest.

    PKIX (Cloud KMS)

    1. Cliquez sur Add a PKIX Key (Ajouter une clé PKIX).
    2. Cliquez sur Importer à partir de Cloud KMS.
    3. Dans la fenêtre qui s'ouvre, saisissez l'ID de ressource correspondant à la version de clé. L'ID de ressource suit le format ci-dessous :

      projects/KMS_KEY_PROJECT_ID/locations/KMS_KEY_LOCATION/keyRings/KMS_KEYRING_NAME/cryptoKeys/KMS_KEY_NAME/cryptoKeyVersions/KMS_KEY_VERSION
      

      Où :

      • KMS_KEY_PROJECT_ID correspond à l'ID du projet dans lequel les clés sont stockées ;
      • KMS_KEY_LOCATION est l'emplacement de la clé (global est la valeur par défaut) ;
      • KMS_KEYRING_NAME correspond au nom du trousseau de clés ;
      • KMS_KEY_NAME correspond au nom de la clé ;
      • KMS_KEY_VERSION correspond à la version de clé.

      Si vous avez créé une paire de clés Cloud KMS à l'aide des exemples de variables d'environnement figurant sur cette page, vous pouvez afficher l'ID de ressource à l'aide de la commande suivante :

      echo projects/${KMS_KEY_PROJECT_ID}/locations/${KMS_KEY_LOCATION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME}/cryptoKeyVersions/${KMS_KEY_VERSION}
      
    4. Cliquez sur Envoyer.

  7. Cliquez sur Créer.

Vérifier que le certificateur a bien été créé

Pour vérifier que le certificateur a bien été créé, procédez comme suit :

  1. Revenez à la page "Binary Authorization" (Autorisation binaire) dans Google Cloud Console.

  2. Accédez à l'onglet Attestors (Certificateurs).

Configuration multiprojets

Dans le cadre d'une configuration multiprojets comportant des projets déployant et certifiant distincts, vous devez définir des autorisations supplémentaires sur la ressource de certificateur afin que le projet déployant soit en mesure, lors du déploiement, d'utiliser les attestations créées par le projet certifiant.

Ajouter une liaison de rôle IAM pour le projet déployant

Vous devez ajouter une liaison de rôle IAM avec le certificateur pour le compte de service du projet déployant. Celle-ci est utilisée par l'autorisation binaire lorsqu'elle évalue une stratégie pour déterminer si le compte dispose des autorisations nécessaires pour accéder au certificateur.

Vous devez ajouter la liaison de rôle IAM à partir de la ligne de commande, car cette étape n'est pas disponible dans Google Cloud Console.

Pour ajouter la liaison de rôle IAM, procédez comme suit :

  1. Configurez des variables d'environnement pour stocker les noms et les numéros de vos projets.

    DEPLOYER_PROJECT_ID=PROJECT_ID
    DEPLOYER_PROJECT_NUMBER="$(
        gcloud projects describe "${DEPLOYER_PROJECT_ID}" \
          --format="value(projectNumber)"
    )"
    
  2. Configurez des variables d'environnement pour stocker les noms des comptes de service associés aux projets :

    DEPLOYER_SERVICE_ACCOUNT="service-${DEPLOYER_PROJECT_NUMBER}@gcp-sa-binaryauthorization.iam.gserviceaccount.com"
    
  3. Ajoutez la liaison de rôle IAM :

    gcloud --project ATTESTOR_PROJECT_ID \
        beta container binauthz attestors add-iam-policy-binding \
        "projects/ATTESTOR_PROJECT_ID/attestors/ATTESTOR" \
        --member="serviceAccount:${DEPLOYER_SERVICE_ACCOUNT}" \
        --role=roles/binaryauthorization.attestorsVerifier
    

Ajouter une liaison de rôle IAM pour l'utilisateur configurant l'autorisation binaire

Vous devez ajouter une liaison de rôle IAM pour l'utilisateur qui ajoute un certificateur à la stratégie d'autorisation binaire dans le projet déployant, car cet utilisateur doit être autorisé à afficher le certificateur à ajouter. Si vous le souhaitez, cette autorisation peut être révoquée en toute sécurité après l'ajout du certificateur.

Vous devez ajouter la liaison de rôle IAM à partir de la ligne de commande, car cette étape n'est pas disponible dans Google Cloud Console.

Pour ajouter la liaison de rôle IAM, exécutez la commande suivante :

gcloud --project ATTESTOR_PROJECT_ID \
    beta container binauthz attestors add-iam-policy-binding \
    "projects/ATTESTOR_PROJECT_ID/attestors/ATTESTOR" \
    --member=ADMIN_EMAIL_ACCOUNT \
    --role=roles/binaryauthorization.attestorsViewer

Pour supprimer la liaison de rôle IAM une fois le certificateur ajouté, exécutez la commande suivante :

gcloud --project ATTESTOR_PROJECT_ID \
    beta container binauthz attestors remove-iam-policy-binding \
    "projects/ATTESTOR_PROJECT_ID/attestors/ATTESTOR" \
    --member=ADMIN_EMAIL_ACCOUNT \
    --role=roles/binaryauthorization.attestorsViewer

Étape suivante