Créer des certificateurs à l'aide de la console Google Cloud

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

Utilisateurs de Cloud Build: vous pouvez utiliser le certificateur built-by-cloud-build pour déployer uniquement des images créées par Cloud Build.

Avant de commencer

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

Présentation

Un certificateur est une ressource Google Cloud 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 (Cloud KMS)

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

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

Créez le trousseau de clés.

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

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}

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 :

Générez la clé :

PRIVATE_KEY_FILE="/tmp/ec_private.pem"
openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}

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}
```

Créer le certificateur

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

L'autorisation binaire utilise Artifact 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 Artifact Analysis. Chaque attestation est stockée en tant qu'occurrence de cette note.

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

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

Accéder à la page "Autorisation binaire"
Dans l'onglet Attestors (Certificateurs), cliquez sur Create (Créer).
Cliquez sur Create New Attestor (Créer un certificateur).
Dans le champ Attestor Name (Nom du certificateur), saisissez le nom du certificateur (par exemple, build-secure ou prod-qa).
Pour ajouter la clé publique au certificateur, procédez comme suit:
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}
```
  Pour ajouter la clé, vous devez disposer du rôle "cloudkms.publicKeyViewer" sur la ressource de clé.
4. Cliquez sur Envoyer.
Si vous souhaitez utiliser une note existante que vous avez créée précédemment, développez la section Paramètres avancés.
1. Désélectionnez Générer automatiquement une note Artifact Analysis.
2. Saisissez le nom complet dans le champ ID de note Artifact Analysis. Le nom suit le format projects/PROJECT_ID/notes/NOTE_ID.
Cliquez sur Create (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 :

Revenez à la page "Autorisation binaire" dans Google Cloud Console.
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 :

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)"
)"

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"

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, procédez comme suit :

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

Étapes suivantes

Découvrez comment créer des attestations pour votre certificateur.
Mettez à jour votre stratégie d'autorisation binaire pour exiger des attestations en utilisant la console Google Cloud, Google Cloud CLI et l'API REST.