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 la CBA pour sécuriser l'accès des appareils approuvés aux applications Web d'entreprise exécutées sur Google Cloud.

Présentation

La CBA 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 TLS mutuelle (mTLS). Voici les principaux composants avec lesquels vous travaillez pour activer la CBA 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 lorsque vous utilisez le navigateur Chrome.

Avant de commencer

Vérifiez que vous disposez d'une version à jour de la Google Cloud CLI 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 à l'étape suivante.

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), à l'aide de votre propre certificat (méthode 2) ou à l'aide d'un certificat autosigné avec la validation de 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 située entre les repères BEGIN CERTIFICATE et END CERTIFICATE, et inclut les deux repères.
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 ancre de confiance au format PEM.
  - IM_CERT_PATH: chemin d'accès à votre certificat intermédiaire au format PEM.
  - SECOND_IM_CERT_PATH: chemin d'accès à votre deuxième certificat intermédiaire 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 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 de confiance nommée TRUST_CONFIG_NAME. La configuration de confiance contient un truststore, qui comprend le certificat racine et deux certificats intermédiaires.
4. Importez la configuration de confiance dans le Google Cloud gestionnaire de certificats:
```
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 Google Cloud projet.

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 de 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 ancre de confiance au format PEM.
- IM_CERT_PATH: chemin d'accès à votre certificat intermédiaire au format PEM.
- SECOND_IM_CERT_PATH: chemin d'accès à votre deuxième certificat intermédiaire encodé en 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 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 de confiance nommée TRUST_CONFIG_NAME. La configuration de confiance contient un truststore, qui comprend le certificat racine et deux certificats intermédiaires.
Importez la configuration de confiance dans le Google Cloud gestionnaire de certificats:
```
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 Google Cloud projet.

Méthode 3

Si vous utilisez un navigateur Chrome et que vous souhaitez utiliser un certificat autosigné avec la validation des points de terminaison, suivez les instructions de cette section.

Suivez les instructions pour déployer la validation des points de terminaison pour votre organisation. Endpoint Verification déploie automatiquement un certificat autosigné émis par Google sur vos appareils. Vous n'avez donc 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 ce 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 Google Cloud projet.
- TRUST_CONFIG_NAME: configuration de confiance que vous avez créée à une étape précédente.
Pour en savoir plus sur les options de validation du client pour clientValidationMode, consultez la section Modes de validation des clients 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' Google Cloud ID du projet.

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, puis 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 vers 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 Google Cloud projet.

Ajoutez ServerTlsPolicy à la configuration du proxy HTTPS cible:

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes:
- networksecurity.serverTlsPolicies.use sur l'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 Google Cloud projet.
- 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 Google Cloud projet.

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 l'association 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 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 d'accès à la configuration de confiance.

Remplacez les éléments suivants :
- GCP_PROJECT: ID du Google Cloud projet.
- 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 la liaison 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 l'association 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 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 d'accès à la configuration de confiance.

Remplacez les éléments suivants :
- GCP_PROJECT: ID du Google Cloud projet.
- 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 ne disposez pas de configuration de confiance, car vous utilisez un certificat autosigné avec la validation des points de terminaison (méthode 3), ajoutez l'expression suivante à votre niveau d'accès personnalisé:

certificateBindingState(origin, device) == CertificateBindingState.CERT_MATCHES_EXISTING_DEVICE

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

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

Pour activer les achats intégrés et configurer la règle CBA, procédez comme suit:

Si vous n'avez pas configuré l'IAP, suivez les instructions pour le configurer.
Accédez à l'API IAP pour associer le niveau d'accès que vous avez créé précédemment:
Accéder à l'API 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 configurer une règle CBA dans l'API Play Store à l'aide de Google Cloud CLI, 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 lors de la détermination de l'accès, suivez la procédure pour votre navigateur.

Chrome

Configurez la règle Chrome AutoSelectCertificateForURLs afin 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 et Linux: suivez la procédure pour configurer un profil Chrome géré.
- Chrome: enregistrez l'appareil auprès de l'entreprise.
Ajoutez la stratégie 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 stratégie 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 Endpoint Verification:

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

Safari

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

Ouvrez l'application Keychain Access (Trousseau d'accès), puis sélectionnez All Items (Tous les éléments).
Sélectionnez le certificat que vous souhaitez configurer.
Cliquez sur File > New Identity Preference (Fichier > Nouvelle préférence d'identité).
Saisissez l'URL, puis cliquez sur Ajouter.

Une entrée de préférence d'identité est alors créée dans votre trousseau de clés et vous pouvez la modifier.

Edge

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