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

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

Cette page explique comment activer les applications basées sur des certificats accès 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éseau Google Cloud pour sécuriser l'accès grâce à des TLS (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.
Équilibreur de charge HTTPS Google Cloud: fournit une authentification mutuelle (mTLS) entre des utilisateurs et des 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 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 externe HTTPS. 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ésentent votre type d'infrastructure à clé publique (PKI).

Pour effectuer cette tâche, vous devez disposer du 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 est 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 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 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 Google Cloud Certificate Manager :
```
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 de 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 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 approbation qui représente 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 encodé 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 Google Cloud Certificate Manager :
```
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 de projet Google Cloud.

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 de projet Google Cloud.
- TRUST_CONFIG_NAME: configuration de confiance que vous créé à une étape précédente.
Pour en savoir plus sur les options de validation du client pour clientValidationMode, consultez la section 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, 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 de 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 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 de projet Google Cloud.
- SERVER_TLS_POLICY_NAME: règle TLS du serveur
Mettez à jour le proxy HTTPS cible en important la nouvelle configuration :
```
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 de 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 ce qui suit : dans le champ Conditions de votre niveau d'accès personnalisé à utiliser PKI-attestation 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 représentant 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 de projet Google Cloud.
- TRUST_CONFIG_NAME: nom de votre configuration de confiance.
Si vous avez utilisé un document autosigné délivré par Google (méthode 3), ajoutez l'expression suivante dans la section champ Conditions de votre niveau d'accès personnalisé pour utiliser le certificat lors de l'authentification:
```
certificateBindingState(origin, device) == CertificateBindingState.CERT_MATCHES_EXISTING_DEVICE
```

gcloud

Si vous avez créé une configuration de confiance (méthode 1 ou méthode 2), exécutez la commande suivante : pour créer un niveau d'accès personnalisé qui utilise PKI-attestation 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 de 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 modèle 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é IAP, suivez les instructions pour configurer IAP.
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 la 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 IAP à l'aide de la Google Cloud CLI, consultez la documentation de 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 adaptée à 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 le cloud du navigateur Chrome ou stratégie de groupe Windows:
- Windows, macOS, 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 des règles. Voici un exemple de configuration de stratégie 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 File > New Identity Preference (Fichier > Nouvelle préférence d'identité).
Saisissez l'URL, puis cliquez sur Ajouter.

Une nouvelle entrée de préférence d'identité est alors créée dans votre trousseau que vous pouvez modifier.

Edge

Définissez la stratégie Edge AutoSelectCertificateForUrls en suivant les instructions de la documentation Edge.