Utiliser mTLS de l'interface avec Secure Web Proxy

Vous pouvez configurer l'authentification TLS mutuelle (mTLS) de l'interface sur Secure Web Proxy pour améliorer la sécurité de vos charges de travail, telles que les agents d'IA. Secure Web Proxy utilise l'authentification mTLS de l'interface pour vérifier les identités des clients à l'aide de certificats.

Cette intégration vous permet d'utiliser des identités client validées dans les règles d'autorisation Secure Web Proxy pour appliquer un contrôle des accès précis au trafic sortant.

Fonctionnement

Les étapes suivantes expliquent comment Secure Web Proxy utilise l'authentification mTLS de l'interface pour sécuriser le trafic sortant :

  • Connexion de proxy explicite : vous pouvez configurer le client pour qu'il utilise Secure Web Proxy comme proxy explicite. Le client lance une requête HTTPS CONNECT vers l'interface Secure Web Proxy au lieu de se connecter directement à Internet.

  • Handshake TLS mutuel : lors de la configuration de la connexion, Secure Web Proxy et le client effectuent un handshake mTLS au niveau de l'interface du proxy. Le proxy utilise une ressource TrustConfig configurée pour valider le certificat du client, tandis que le client valide le certificat de serveur du proxy.

  • Extraction d'identité : après un handshake réussi, Secure Web Proxy extrait des attributs d'identité uniques, tels que URI_SAN, directement à partir du certificat client validé.

  • Autorisation basée sur l'identité : Secure Web Proxy évalue la requête sortante par rapport aux règles d'autorisation que vous avez configurées. Pour déterminer si la requête est autorisée, le proxy utilise l'identité du client, qui a été vérifiée de manière cryptographique lors du handshake mTLS.

  • Trafic sortant sécurisé : une fois la requête autorisée et s'il existe une règle correspondante pour une destination externe, Secure Web Proxy l'envoie à la destination.

Principaux avantages

La configuration de l'authentification mTLS de l'interface sur Secure Web Proxy offre les avantages suivants en termes de sécurité et d'exploitation :

  • Sécurité renforcée : obtenez un accès zéro confiance en exigeant l'authentification mTLS de l'interface pour tout le trafic sortant. Cela garantit que seules les charges de travail dont l'identité a été vérifiée peuvent établir une connexion avec le proxy pour accéder aux services externes.

  • Configuration simplifiée des charges de travail : utilisez le mode de routage de proxy explicite pour Secure Web Proxy afin de tirer parti de la capacité du proxy à intercepter et à authentifier les requêtes.

  • Contrôle précis : appliquez des règles détaillées et basées sur l'identité pour déterminer les services externes auxquels chaque charge de travail spécifique peut accéder.

Exemple d'utilisation : valider l'identité de vos charges de travail

Dans les secteurs fortement réglementés et soumis à des exigences de conformité strictes, comme le secteur bancaire, la vérification de l'emplacement réseau d'une requête ne suffit pas à empêcher l'accès non autorisé aux données. En configurant l'authentification mTLS de l'interface sur Secure Web Proxy, les organisations peuvent passer à un modèle d'identité vérifié de manière cryptographique. Cela garantit que chaque charge de travail, qu'il s'agisse d'une instance de machine virtuelle (VM) ou d'un agent d'IA, doit prouver son identité spécifique à l'aide d'un certificat approuvé.

Cette approche permet aux administrateurs d'appliquer des garde-fous basés sur l'identité qui protègent les chemins sortants sensibles. Par exemple, une banque peut s'assurer que seule une charge de travail spécifique de traitement des paiements authentifiée peut atteindre une passerelle financière externe.

Configurer l'authentification mTLS de l'interface pour Secure Web Proxy

Cette section décrit les étapes à suivre pour configurer l'authentification mTLS de l'interface pour votre instance Secure Web Proxy.

Avant de commencer

Créer les certificats racine et intermédiaires

Cette section explique comment utiliser OpenSSL pour générer un certificat d'autorité de certification racine (l'ancre de confiance) et un certificat d'autorité de certification intermédiaire facultatif. Secure Web Proxy utilise ces certificats pour vérifier les certificats client que les charges de travail présentent lors du processus de handshake mTLS de l'interface. Ce processus manuel est destiné aux environnements de test et de développement afin de fournir l'ancre de confiance dont Secure Web Proxy a besoin pour vérifier les certificats client.

Un certificat racine se trouve en haut de la chaîne de certificats, tandis qu'un certificat intermédiaire sert de pont dans la chaîne de confiance vers la racine. Le certificat intermédiaire est signé de manière cryptographique par le certificat racine. Lorsque Secure Web Proxy reçoit un certificat client, il valide l'identité en établissant une chaîne de confiance entre le certificat client et l'ancre de confiance configurée.

Utilisez les commandes suivantes pour créer les certificats racine et intermédiaires. Bien que le certificat intermédiaire soit facultatif, cette configuration l'utilise pour signer le certificat client afin d' afficher une hiérarchie de certificats à plusieurs niveaux.

  1. Créez un fichier de configuration OpenSSL.

    cat > example.cnf << EOF
[req]
distinguished_name = empty_distinguished_name

[empty_distinguished_name]
# Kept empty to allow setting via -subj command-line argument.

[ca_exts]
basicConstraints=critical,CA:TRUE
keyUsage=keyCertSign
extendedKeyUsage=clientAuth
EOF

  2. Créez un certificat racine X.509 autosigné (root.cert) et une clé privée (root.key).

    openssl req -x509 \
    -new -sha256 -newkey rsa:2048 -nodes \
    -days 3650 -subj '/CN=root' \
    -config example.cnf \
    -extensions ca_exts \
    -keyout root.key -out root.cert

  3. Créez la demande de signature de certificat (int.req) pour le certificat intermédiaire.

    openssl req -new \
    -sha256 -newkey rsa:2048 -nodes \
    -subj '/CN=int' \
    -config example.cnf \
    -extensions ca_exts \
    -keyout int.key -out int.req

  4. Signez la demande de signature de certificat (CSR) pour créer le certificat intermédiaire X.509 (int.cert).

    openssl x509 -req \
    -CAkey root.key -CA root.cert \
    -set_serial 1 \
    -days 3650 \
    -extfile example.cnf \
    -extensions ca_exts \
    -in int.req -out int.cert

Créer un certificat client pour les tests

Créez un certificat feuille et une clé privée pour votre charge de travail client de test. Lors du processus de handshake mTLS avec votre instance Secure Web Proxy, le client fournit ce certificat feuille pour prouver son identité.

L'exemple suivant utilise OpenSSL pour générer une clé client et une CSR, puis signe la CSR avec la clé d'autorité de certification intermédiaire que vous avez créée dans la section Créer les certificats racine et intermédiaires.

  1. Exécutez la commande OpenSSL suivante pour générer une clé privée RSA nommée client.key :

    openssl genpkey -algorithm RSA -out client.key

  2. Créez un fichier de configuration nommé client.cnf qui spécifie un nom DNS pour le nom alternatif du sujet (SAN). Cela permet de s'assurer que le certificat est compatible avec les exigences de sécurité modernes.

    cat > client.cnf << EOF
[req]
distinguished_name = req_distinguished_name
req_extensions = v3_req
prompt = no

[req_distinguished_name]
CN = my-client.example.com

[v3_req]
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = clientAuth
subjectAltName = @alt_names

[alt_names]
DNS.1 = my-client.example.com

EOF

    Vous pouvez modifier les valeurs CN et DNS.1 selon vos besoins pour les tests.

  3. Exécutez la commande de requête OpenSSL à l'aide de la clé privée et du fichier de configuration que vous avez créés pour générer un fichier client.req.

    openssl req -new -key client.key -out client.req -config client.cnf

  4. Utilisez la commande OpenSSL x509 pour signer la requête à l'aide de votre certificat intermédiaire (int.cert) et de votre clé (int.key). Définissez une période de validité, par exemple 365 jours, et assurez-vous que les extensions de votre fichier de configuration sont appliquées au fichier client.cert généré.

    openssl x509 -req -in client.req -CA int.cert -CAkey int.key \
  -set_serial 02 -days 365 -out client.cert \
  -extfile client.cnf -extensions v3_req

    Ce processus crée le fichier client.cert. Enregistrez la valeur utilisée dans le SAN DNS (par exemple, my-client.example.com) comme identité de votre client. Vous pouvez utiliser cette valeur pour identifier la charge de travail lorsque vous créez vos règles d'autorisation Secure Web Proxy.

Mettre en forme les certificats

Mettez en forme les certificats racine et intermédiaires dans des variables d’environnement à utiliser dans le fichier trust_config.yaml.

  export ROOT_CERT=$(cat root.cert | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
  export INTERMEDIATE_CERT=$(cat int.cert | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

Créer une ressource de configuration de confiance

Une configuration de confiance représente votre infrastructure à clé publique (PKI) dans Certificate Manager. La configuration de confiance indique à votre instance Secure Web Proxy les certificats d'autorité de certification à approuver lors de la vérification des certificats client présentés lors d'un handshake mTLS de l'interface.

Cet exemple de ressource de configuration de confiance contient un magasin de confiance avec un seul magasin de confiance contenant une ancre de confiance (autorité de certification racine) et une autorité de certification intermédiaire. Il utilise le contenu du certificat à partir des variables d'environnement que vous avez créées dans la section précédente, Mettre en forme les certificats.

  1. Créez un fichier trust_config.yaml.

    cat << EOF > trust_config.yaml
trustStores:
  TRUST_CONFIG_NAME:
    trustAnchors:
      - pemCertificate: |
        -----BEGIN CERTIFICATE-----
        <certificate content>
        -----END CERTIFICATE-----
    intermediateCAs:
      - pemCertificate: |
        -----BEGIN CERTIFICATE-----
        <certificate content>
        -----END CERTIFICATE-----

EOF

    Remplacez TRUST_CONFIG_NAME par le nom de votre ressource de configuration de confiance.

  2. Importez le fichier trust config.yaml à l'aide de la gcloud certificate-manager trust-configs import commande.

    gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME\
  --source=trust_config.yaml \
  --location=LOCATION

    Remplacez les éléments suivants :

    • TRUST_CONFIG_NAME : nom de votre ressource de configuration de confiance

    • LOCATION: région dans laquelle votre ressource de configuration de confiance est stockée

Créer une ressource ServerTlsPolicy

Une ressource ServerTlsPolicy, également appelée ressource d'authentification client, définit la manière dont Secure Web Proxy valide les certificats client. Elle vous permet de spécifier le mode TLS côté serveur et la ressource de configuration de confiance pour la vérification des certificats.

L'attribut clientValidationMode détermine la manière dont la connexion est gérée lorsqu'un client fournit un certificat non valide ou aucun certificat. Pour en savoir plus, consultez la section Modes de validation des clients mTLS de l'interface.

Les valeurs de l'attribut clientValidationMode sont les suivantes :

  • REJECT_INVALID: Secure Web Proxy n'autorise que les connexions des clients qui présentent un certificat valide signé par une autorité de certification dans votre configuration de confiance. Les connexions avec des certificats non valides ou manquants sont refusées.

  • ALLOW_INVALID_OR_MISSING_CLIENT_CERT: Secure Web Proxy autorise la requête de connexion même si le certificat client n'est pas valide, ne peut pas être validé par rapport à votre configuration de confiance ou est totalement manquant.

Pour créer une ressource ServerTlsPolicy, procédez comme suit :

  1. Créez un fichier server_tls_policy.yaml. Choisissez l'une des options suivantes pour clientValidationMode :

    • Option 1: ALLOW_INVALID_OR_MISSING_CLIENT_CERT
    name: SERVER_TLS_POLICY_NAME
mtlsPolicy:
  clientValidationMode: ALLOW_INVALID_OR_MISSING_CLIENT_CERT
  clientValidationTrustConfig: projects/PROJECT_ID/locations/LOCATION/trustConfigs/TRUST_CONFIG_NAME
    • Option 2: REJECT_INVALID
    name: SERVER_TLS_POLICY_NAME
mtlsPolicy:
  clientValidationMode: REJECT_INVALID
  clientValidationTrustConfig: projects/PROJECT_ID/locations/LOCATION/trustConfigs/TRUST_CONFIG_NAME

    Remplacez les éléments suivants :

    • SERVER_TLS_POLICY_NAME : nom de votre ressource ServerTlsPolicy

    • PROJECT_ID: ID de votre Google Cloud projet

    • TRUST_CONFIG_NAME : nom de votre ressource de configuration de confiance

    • LOCATION: région dans laquelle votre instance Secure Web Proxy est configurée

  2. Importez la ressource ServerTlsPolicy à l'aide de la gcloud network-security server-tls-policies import commande.

    gcloud network-security server-tls-policies import SERVER_TLS_POLICY_NAME\
  --source=server_tls_policy.yaml \
  --location=LOCATION

    Remplacez les éléments suivants :

    • SERVER_TLS_POLICY_NAME : nom de votre ressource ServerTlsPolicy

    • LOCATION: région dans laquelle votre instance Secure Web Proxy est configurée

  3. (Facultatif) Pour afficher la liste de toutes vos ressources ServerTlsPolicies, utilisez la gcloud network-security server-tls-policies list commande.

    gcloud network-security server-tls-policies list \
  --location=LOCATION

    Remplacez LOCATION par la région dans laquelle votre instance Secure Web Proxy est configurée.

Associer la ressource ServerTlsPolicy à votre instance Secure Web Proxy

  1. Ajoutez la ressource ServerTlsPolicy au fichier gateway.yaml de votre instance Secure Web Proxy.

    echo "serverTlsPolicy:
//networksecurity.googleapis.com/projects/PROJECT_ID/locations/
LOCATION/serverTlsPolicies/SERVER_TLS_POLICY_NAME"
>> gateway.yaml

    Remplacez les éléments suivants :

    • PROJECT_ID: ID de votre Google Cloud projet

    • LOCATION: région dans laquelle votre instance Secure Web Proxy est configurée

  2. Importez la configuration de votre instance Secure Web Proxy à partir du gateway.yaml fichier à l'aide de la gcloud network-services gateways import commande.

    gcloud network-services gateways import GATEWAY_NAME\
    --source=gateway.yaml \
    --location=LOCATION

    Remplacez les éléments suivants :

    • GATEWAY_NAME : nom de votre instance Secure Web Proxy

    • LOCATION: région dans laquelle votre instance Secure Web Proxy est configurée

Configurer les règles d'autorisation

Pour en savoir plus, consultez la section Configurer des règles d'autorisation pour Secure Web Proxy.

Journalisation

Pour en savoir plus, consultez la section Gestion des erreurs et journalisation de l'authentification mTLS de l'interface.

Limites

Pour en savoir plus, consultez la section Limites de l'authentification mTLS de l'interface.

Étape suivante