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'accès basé sur les certificats pour sécuriser l'accès depuis des appareils de confiance aux applications Web d'entreprise exécutées sur Cloud de Confiance by S3NS.

Présentation

L'accès basé sur les certificats pour les applications Web utilise les fonctionnalités d'accès contextuel et Cloud de Confiance de mise en réseau de Chrome Enterprise Premium pour sécuriser l'accès à l'aide du protocole TLS mutuel (mTLS). Voici les principaux composants avec lesquels vous travaillez pour activer l'accès basé 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.
  • Cloud de Confiance É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 actuelle de 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 lors d'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' certificatemanager.trustconfigs.create autorisation sur le target Cloud de Confiance project.

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 des points de terminaison (méthode 3).

Méthode 1

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

  1. Suivez la procédure décrite dans Créer une autorité de certification racine.

  2. 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.

  3. Récupérez le certificat racine, renvoyé dans le champ pemCaCertificates. Le certificat est la chaîne comprise entre les marqueurs BEGIN CERTIFICATE et END CERTIFICATE, et inclut les deux marqueurs.

  4. Enregistrez le certificat racine au format PEM dans un fichier.

  5. 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 encodée 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 magasin de confiance, qui inclut le certificat racine et deux certificats intermédiaires.

    4. Importez la configuration de confiance dans le gestionnaire de certificats : Cloud de Confiance by S3NS 

      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. Cloud de Confiance by S3NS

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 :

  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 encodée 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 magasin de confiance, qui inclut le certificat racine et deux certificats intermédiaires.

  4. Importez la configuration de confiance dans le gestionnaire de certificats : Cloud de Confiance by S3NS 

    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. Cloud de Confiance by S3NS

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. La validation des points de terminaison 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 :

  1. Créez le fichier YAML de 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. Cloud de Confiance by S3NS
    • TRUST_CONFIG_NAME : configuration de confiance que vous avez créée lors d'une étape précédente.

    Pour en savoir plus sur les options de validation du client pour clientValidationMode, consultez Modes de validation du client MTLS.

  2. Importez le fichier YAML de règle TLS du serveur dans le Cloud de Confiance by S3NS projet :

    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 Cloud de Confiance by S3NS projet.

Une fois que vous avez créé une règle TLS, vous ne pouvez plus la modifier. Si vous souhaitez apporter des modifications à 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 target Cloud de Confiance project.

  1. 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. Cloud de Confiance by S3NS

  2. Ajoutez la ServerTlsPolicy à la configuration du proxy HTTPS cible :

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

    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. Cloud de Confiance by S3NS
    • SERVER_TLS_POLICY_NAME : règle TLS du serveur.

  3. 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. Cloud de Confiance by S3NS

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

Console

  1. Suivez les instructions pour créer un niveau d'accès personnalisé.

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

    Remplacez les éléments suivants :

    • GCP_PROJECT : ID du projet. Cloud de Confiance by S3NS
    • TRUST_CONFIG_NAME : nom de votre configuration de confiance.

    Si vous avez utilisé un certificat autosigné é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 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 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 par l'humain.

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

    Remplacez les éléments suivants :

    • GCP_PROJECT : ID du projet. Cloud de Confiance by S3NS
    • TRUST_CONFIG_NAME : nom de votre configuration de confiance.

  • DESCRIPTION : description détaillée du niveau d'accès.

  • POLICY_NAME : règle d'accès de votre organisation.

Si vous ne disposez pas d'une 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 l'accès basé sur les certificats à l'aide d'Identity-Aware Proxy (IAP)

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

Pour activer IAP et configurer la règle d'accès basé sur les certificats, procédez comme suit :

  1. Si IAP n'est pas configuré, suivez les instructions pour le configurer.
  2. Accédez à IAP pour associer le niveau d'accès que vous avez créé précédemment :
    Accéder à IAP
  3. Sélectionnez la ressource que vous souhaitez sécuriser avec l'accès basé sur les certificats, puis cliquez sur Paramètres.
  4. 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 d'accès basé sur les certificats dans IAP, 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 correspondant à votre navigateur.

Chrome

Configurez la règle Chrome AutoSelectCertificateForURLs afin que Chrome utilise le bon certificat lors de l'établissement de la liaison mTLS.

  1. Assurez-vous que le navigateur Chrome est géré par la gestion cloud du navigateur Chrome ou par la stratégie de groupe Windows :

  2. 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électionner 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 la règle. 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é :

  1. Ouvrez l'application Keychain Access (Trousseau d'accès), puis sélectionnez All Items (Tous les éléments).
  2. Sélectionnez le certificat que vous souhaitez configurer.
  3. Cliquez sur File > New Identity Preference (Fichier > Nouvelle préférence d'identité).
  4. Saisissez l'URL, puis cliquez sur Add (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 Edge AutoSelectCertificateForUrls en suivant les instructions de la documentation Edge.