Cette page a été traduite par l'API Cloud Translation.

Activer l'accès basé sur des certificats pour les applications Web

Cette page explique comment activer l'accès basé sur les certificats (CBA) pour vos applications Web. Vous pouvez utiliser l'authentification basée sur les certificats pour sécuriser l'accès depuis des appareils de confiance aux applications Web d'entreprise s'exécutant sur Google Cloud.

Présentation

L'authentification basée sur les certificats pour les applications Web utilise les fonctionnalités d'accès contextuel de Chrome Enterprise Premium et la mise en réseauGoogle Cloud pour sécuriser l'accès à l'aide de l'authentification mutuelle TLS (mTLS). Voici les principaux composants avec lesquels vous travaillez pour activer l'authentification basée sur les certificats pour les applications Web :

Access Context Manager : vous permet de créer des niveaux d'accès nécessitant des certificats pour déterminer l'accès aux applications Web.
Identity-Aware Proxy (IAP) : authentifie l'accès des utilisateurs aux applications Web.
Google Cloud Équilibreur de charge HTTPS : fournit une authentification mutuelle (mTLS) entre les utilisateurs et les applications Web.
Règle Chrome Enterprise : fournit une authentification mutuelle (mTLS) entre les utilisateurs et les applications Web lorsqu'ils utilisent le navigateur Chrome.

Avant de commencer

Vérifiez que vous disposez d'une version à jour de la CLI Google Cloud en exécutant la commande suivante :

gcloud components update

Configurer mTLS pour l'équilibreur de charge HTTPS externe

Suivez les instructions pour configurer l'équilibreur de charge HTTPS externe. Notez le nom du proxy HTTPS cible créé, car vous en aurez besoin à une étape ultérieure.

Créer une configuration de confiance

Créez une configuration de confiance pour représenter votre type d'infrastructure à clé publique (PKI).

Pour effectuer cette tâche, vous devez disposer de l'autorisation certificatemanager.trustconfigs.create sur le projet Google Cloud cible.

Vous pouvez créer une configuration de confiance à l'aide d'un certificat émis par Google (méthode 1), de votre propre certificat (méthode 2) ou d'un certificat autosigné avec la validation du point de terminaison (méthode 3).

Méthode 1

Utilisez un certificat émis par Google pour créer une configuration de confiance.

Suivez la procédure pour créer une autorité de certification racine.
Récupérez le contenu du fichier PEM :
```
gcloud privateca roots describe ROOT_CA_ID \
    --pool=POOL_ID \
    --location=CA_LOCATION \
    --format='value(pemCaCertificates)'
```
Remplacez les éléments suivants :
- ROOT_CA_ID : ID du certificat racine.
- POOL_ID : ID du pool de certificats racine.
- CA_LOCATION : emplacement de l'autorité de certification.
Récupérez le certificat racine, renvoyé dans le champ pemCaCertificates. Le certificat correspond à la chaîne comprise entre les marqueurs BEGIN CERTIFICATE et END CERTIFICATE, et inclut les deux marqueurs.
Enregistrez le certificat racine au format PEM dans un fichier.
Créez une configuration de confiance :
1. Définissez les variables d'environnement suivantes :
```
ROOT_PEM_FILE=TRUST_ANCHOR_PATH
INT_PEM_FILE1=IM_CERT_PATH
INT_PEM_FILE2=SECOND_IM_CERT_PATH
```
  Remplacez les éléments suivants :
  - TRUST_ANCHOR_PATH : chemin d'accès à votre point d'ancrage de confiance encodé au format PEM.
  - IM_CERT_PATH : chemin d'accès à votre certificat intermédiaire encodé au format PEM.
  - SECOND_IM_CERT_PATH : chemin d'accès à votre deuxième certificat intermédiaire encodé au format PEM.
2. Préparez le contenu du fichier YAML de configuration de confiance :
```
ROOT=$(cat ROOT_PEM_FILE | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_1=$(cat INT_PEM_FILE1 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_2=$(cat INT_PEM_FILE2 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
```
3. Créez le fichier YAML de configuration de la confiance :
```
cat << EOF > trust_config.yaml
name: "${TRUST_CONFIG_NAME?}"
trustStores:
- trustAnchors:
  - pemCertificate: "${ROOT?}"
  intermediateCas:
  - pemCertificate: "${INT_1?}"
  - pemCertificate: "${INT_2?}"
 EOF
```
  Ce fichier YAML définit une configuration d'approbation nommée TRUST_CONFIG_NAME. La configuration de confiance contient un magasin de confiance, qui inclut le certificat racine et deux certificats intermédiaires.
4. Importez la configuration de confiance dans le gestionnaire de certificats Google Cloud :
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME \
  --project=GCP_PROJECT \
  --source=${PWD?}/trust_config.yaml
```
  Remplacez les éléments suivants :
  - TRUST_CONFIG_NAME : nom de votre configuration de confiance.
  - GCP_PROJECT : ID du projet Google Cloud .

Si vous déployez une structure plus complexe avec des autorités de certification intermédiaires signées par la racine, assurez-vous d'ajouter vos intermédiaires en tant que intermediateCAs.

Méthode 2

Utilisez votre propre déploiement PKI avec des certificats existants pour créer une configuration de confiance.

Ce type de configuration de confiance suppose un magasin de confiance de base avec une seule ancre de confiance représentant un certificat racine. Aucun certificat intermédiaire n'est spécifié.

Créez une configuration de confiance :

Définissez les variables d'environnement suivantes :
```
ROOT_PEM_FILE=TRUST_ANCHOR_PATH
INT_PEM_FILE1=IM_CERT_PATH
INT_PEM_FILE2=SECOND_IM_CERT_PATH
```
Remplacez les éléments suivants :
- TRUST_ANCHOR_PATH : chemin d'accès à votre point d'ancrage de confiance encodé au format PEM.
- IM_CERT_PATH : chemin d'accès à votre certificat intermédiaire encodé au format PEM.
- SECOND_IM_CERT_PATH : chemin d'accès à votre deuxième certificat intermédiaire encodé au format PEM.

Préparez le contenu du fichier YAML de configuration de confiance :

ROOT=$(cat ROOT_PEM_FILE | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_1=$(cat INT_PEM_FILE1 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_2=$(cat INT_PEM_FILE2 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

Créez le fichier YAML de configuration de la confiance :
```
cat << EOF > trust_config.yaml
name: "${TRUST_CONFIG_NAME?}"
trustStores:
- trustAnchors:
  - pemCertificate: "${ROOT?}"
  intermediateCas:
  - pemCertificate: "${INT_1?}"
  - pemCertificate: "${INT_2?}"
EOF
```
Ce fichier YAML définit une configuration d'approbation nommée TRUST_CONFIG_NAME. La configuration de confiance contient un magasin de confiance, qui inclut le certificat racine et deux certificats intermédiaires.
Importez la configuration de confiance dans le gestionnaire de certificats Google Cloud :
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME \
  --project=GCP_PROJECT \
  --source=${PWD?}/trust_config.yaml
```
Remplacez les éléments suivants :
- TRUST_CONFIG_NAME : nom de votre configuration de confiance.
- GCP_PROJECT : ID du projet Google Cloud .

Méthode 3

Si vous utilisez un navigateur Chrome et que vous souhaitez utiliser un certificat autosigné avec Endpoint Verification, suivez les instructions de cette section.

Suivez les instructions pour déployer Endpoint Verification pour votre organisation. La validation des points de terminaison déploie automatiquement un certificat auto-signé émis par Google sur vos appareils. Vous n'avez pas besoin de créer de configuration de confiance.

Créer une règle TLS pour activer mTLS sur votre équilibreur de charge externe

Si vous avez utilisé la méthode 3, vous pouvez ignorer cette étape.

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

certificatemanager.trustconfigs.use sur la configuration de confiance que vous avez créée pour cet ServerTlsPolicy
networksecurity.serverTlsPolicies.create sur le projet Google Cloud cible

Créez le fichier YAML de la règle TLS du serveur :
```
cat << EOF > server_tls_policy.yaml
name: "SERVER_TLS_POLICY_NAME"
mtlsPolicy:
  clientValidationMode: ALLOW_INVALID_OR_MISSING_CLIENT_CERT
  clientValidationTrustConfig: projects/GCP_PROJECT/locations/global/trustConfigs/TRUST_CONFIG_NAME
EOF
```
Remplacez les éléments suivants :
- SERVER_TLS_POLICY_NAME : nom de la règle TLS du serveur.
- GCP_PROJECT : ID du projet Google Cloud .
- TRUST_CONFIG_NAME : configuration de l'approbation que vous avez créée à l'étape précédente.
Pour en savoir plus sur les options de validation du client pour clientValidationMode, consultez Modes de validation du client MTLS.

Importez le fichier YAML de la règle TLS du serveur dans le projet Google Cloud :

gcloud network-security server-tls-policies import ${SERVER_TLS_POLICY_NAME?} \
  --project=GCP_PROJECT \
  --source=${PWD?}/server_tls_policy.yaml \
  --location=global

Remplacez GCP_PROJECT par l'ID du projet Google Cloud .

Une fois que vous avez créé une règle TLS, vous ne pouvez plus la modifier. Si vous souhaitez modifier une règle TLS existante, supprimez-la et créez-en une autre.

Associer une règle TLS à une règle HTTPS cible

Pour effectuer cette tâche, vous devez disposer de l'autorisation compute.targetHttpsProxies.get sur le projet Google Cloud cible.

Exportez votre proxy HTTPS cible existant dans un fichier local :

gcloud compute target-https-proxies export TARGET_HTTPS_PROXY_NAME \
    --project=GCP_PROJECT \
    --global \
    --destination=${PWD?}/xlb-mtls-target-proxy.yaml

Remplacez les éléments suivants :

TARGET_HTTPS_PROXY_NAME : proxy HTTPS cible.
GCP_PROJECT : ID du projet Google Cloud .

Ajoutez ServerTlsPolicy à la configuration du proxy HTTPS cible :

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :
- networksecurity.serverTlsPolicies.use sur le ServerTlsPolicy que vous avez créé pour le proxy HTTPS cible
- compute.targetHttpsProxies.update sur le projet Google Cloud cible
```
echo "serverTlsPolicy:
//networksecurity.googleapis.com/projects/GCP_PROJECT/locations/global/serverTlsPolicies/SERVER_TLS_POLICY_NAME" >> xlb-mtls-target-proxy.yaml
```
Remplacez les éléments suivants :
- GCP_PROJECT : ID du projet Google Cloud .
- SERVER_TLS_POLICY_NAME : règle TLS du serveur.
Mettez à jour le proxy HTTPS cible en important la nouvelle configuration à partir du fichier local :
```
gcloud compute target-https-proxies import TARGET_HTTPS_PROXY_NAME \
    --project=GCP_PROJECT \
    --global \
    --source=${PWD?}/xlb-mtls-target-proxy.yaml
```
Remplacez les éléments suivants :
- TARGET_HTTPS_PROXY_NAME : proxy HTTPS cible.
- GCP_PROJECT : ID du projet Google Cloud .

Créer un niveau d'accès nécessitant des certificats

Console

Suivez les instructions pour créer un niveau d'accès personnalisé.
Ajoutez l'expression suivante à votre niveau d'accès personnalisé :

Si vous avez créé une configuration de confiance (méthode 1 ou méthode 2), ajoutez l'expression suivante dans le champ Conditions de votre niveau d'accès personnalisé pour utiliser la liaison d'attestation PKI lors de l'authentification :
```
certIsPkiAttested(origin, ["TLS_POLICY_FULL_RESOURCE_PATH1", "TLS_POLICY_FULL_RESOURCE_PATH2", …]) == true
```
Où TLS_POLICY_FULL_RESOURCE_PATH1 et TLS_POLICY_FULL_RESOURCE_PATH2 sont les chemins d'accès qui représentent plusieurs configurations de confiance : certificatemanager.googleapis.com/projects/GCP_PROJECT/locations/global/trustConfigs/TRUST_CONFIG_NAME.

Vous devez fournir au moins un chemin de configuration de confiance.

Remplacez les éléments suivants :
- GCP_PROJECT : ID du projet Google Cloud .
- TRUST_CONFIG_NAME : nom de votre configuration de confiance.
Si vous avez utilisé un certificat auto-signé émis par Google (méthode 3), ajoutez l'expression suivante dans le champ Conditions de votre niveau d'accès personnalisé pour utiliser l'association de certificat lors de l'authentification :
```
certificateBindingState(origin, device) == CertificateBindingState.CERT_MATCHES_EXISTING_DEVICE
```

gcloud

Si vous avez créé une configuration d'approbation (méthode 1 ou méthode 2), exécutez la commande suivante pour créer un niveau d'accès personnalisé qui utilise la liaison d'attestation PKI lors de l'authentification :

gcloud access-context-manager levels create ACCESS_LEVEL_NAME \
    --title=TITLE \
    --custom-level-spec=FILE \
    --description=DESCRIPTION \
    --policy=POLICY_NAME

Remplacez les éléments suivants :

ACCESS_LEVEL_NAME : nom unique du niveau d'accès.
TITLE : titre lisible.
FILE : fichier YAML contenant l'expression suivante :

certIsPkiAttested(origin, ["TLS_POLICY_FULL_RESOURCE_PATH1", "TLS_POLICY_FULL_RESOURCE_PATH2", …]) == true

Où TLS_POLICY_FULL_RESOURCE_PATH1 et TLS_POLICY_FULL_RESOURCE_PATH2 sont les chemins d'accès qui représentent plusieurs configurations de confiance : certificatemanager.googleapis.com/projects/GCP_PROJECT/locations/global/trustConfigs/TRUST_CONFIG_NAME.

Vous devez fournir au moins un chemin de configuration de confiance.

Remplacez les éléments suivants :
- GCP_PROJECT : ID du projet Google Cloud .
- TRUST_CONFIG_NAME : nom de votre configuration de confiance.
DESCRIPTION : description longue du niveau d'accès.
POLICY_NAME : règle d'accès de votre organisation.

Si vous n'avez pas de configuration de confiance, car vous utilisez un certificat autosigné avec Endpoint Verification (méthode 3), ajoutez l'expression suivante à votre niveau d'accès personnalisé :

certificateBindingState(origin, device) == CertificateBindingState.CERT_MATCHES_EXISTING_DEVICE

Appliquer l'accès basé sur des certificats à l'aide d'Identity-Aware Proxy (IAP)

Dans l'architecture CBA pour les applications Web, IAP fournit une application des règles basée sur les principaux pour protéger vos applications Web contre les appareils non approuvés.

Pour activer IAP et configurer la règle CBA, procédez comme suit :

Si vous n'avez pas configuré IAP, suivez les instructions pour le faire.
Accédez à IAP pour associer le niveau d'accès que vous avez créé précédemment :
Accéder à IAP
Sélectionnez la ressource que vous souhaitez sécuriser avec CBA, puis cliquez sur Paramètres.
Dans le champ Niveaux d'accès, saisissez le nom du niveau d'accès que vous avez créé.

Pour utiliser Google Cloud CLI afin de configurer une règle CBA dans IAP, consultez la documentation Google Cloud CLI.

Configurer le navigateur pour qu'il sélectionne automatiquement le certificat

Pour que votre navigateur sélectionne automatiquement le certificat lorsqu'il détermine l'accès, suivez les étapes correspondant à votre navigateur.

Chrome

Configurez la règle Chrome AutoSelectCertificateForURLs pour que Chrome utilise le bon certificat lors du handshake mTLS.

Assurez-vous que le navigateur Chrome est géré par la gestion cloud du navigateur Chrome ou par la stratégie de groupe Windows :
- Windows, macOS, Linux : suivez la procédure pour configurer un profil Chrome géré.
- Chrome : enregistrez l'appareil dans l'entreprise.
Ajoutez la règle AutoSelectCertificateForUrls :
1. Dans la console d'administration, accédez à Appareils > Chrome > Paramètres > Paramètres des utilisateurs et du navigateur > Certificats client.
2. Sélectionnez une organisation.
3. Ajoutez une règle AutoSelectCertificateForUrls pour l'URL de votre application Web et les informations sur le certificat racine.

Pour en savoir plus, consultez la documentation sur le schéma de règles. Voici un exemple de configuration de règle qui utilise le certificat de la validation des points de terminaison :

{
  "pattern":"https://[*.].mysite.com",
  "Filter":{
    "ISSUER":{
      "CN":"Google Endpoint Verification"
    }
  }
}

Safari

Configurez la préférence d'identité :

Ouvrez l'application Trousseau d'accès, puis sélectionnez Tous les éléments.
Sélectionnez le certificat que vous souhaitez configurer.
Cliquez sur Fichier > Nouvelle préférence d'identité.
Saisissez l'URL, puis cliquez sur Ajouter.

Cela crée une entrée de préférence d'identité dans votre trousseau que vous pouvez mettre à jour.

Edge

Définissez la règle AutoSelectCertificateForUrls Edge en suivant les instructions de la documentation Edge.

Activer l'accès basé sur des certificats pour les applications Web Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.