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èresBEGIN CERTIFICATE
etEND CERTIFICATE
, et inclut les deux repères.Enregistrez le certificat racine au format PEM dans un fichier.
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 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 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.
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 ceServerTlsPolicy
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 ciblecompute.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
:- Dans la console d'administration, accédez à Appareils > Chrome > Paramètres > Paramètres des utilisateurs et du navigateur > Certificats client.
- Sélectionnez une organisation.
- 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.