Configurer un protocole TLS mutuel avec des certificats fournis par l'utilisateur

Cette page fournit des instructions pour créer un certificat racine et un certificat intermédiaire signé, et les importer dans une ressource TrustConfig du gestionnaire de certificats. Si vous avez déjà des certificats à importer, ignorez les étapes suivantes qui permettent de créer des certificats.

Vous allez également créer les ressources de sécurité réseau requises pour configurer l'authentification TLS mutuelle (mTLS) pour les équilibreurs de charge d'application. Les instructions utilisent OpenSSL pour créer les certificats racine et intermédiaires.

Avant de commencer

Consultez la page Présentation du protocole TLS mutuel.
Consultez la page Gérer les configurations de confiance.
Installez Google Cloud CLI. Pour une présentation complète de l'outil, consultez la présentation de gcloud CLI. Vous trouverez des commandes liées à l'équilibrage de charge dans la documentation de référence de l'API et de gcloud CLI.

Si vous n'avez pas encore utilisé gcloud CLI, exécutez d'abord la commande gcloud init pour vous authentifier.
Activer des API : l'API Compute Engine, l'API Certificate Manager, la sécurité réseau et l'API Network Services.
Définissez votre projet.
gcloud
```
gcloud config set project PROJECT_ID
```

Autorisations

Pour obtenir les autorisations nécessaires pour suivre ce guide, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet :

Pour créer des ressources d'équilibreur de charge telles que TargetHTTPSProxy : Administrateur de l'équilibreur de charge Compute (roles/compute.loadBalancerAdmin)
Pour utiliser les ressources du gestionnaire de certificats : Propriétaire du gestionnaire de certificats (roles/certificatemanager.owner)
Pour créer des composants de sécurité et de mise en réseau, procédez comme suit : Administrateur de réseau Compute (roles/compute.networkAdmin) et Administrateur de sécurité Compute (roles/compute.securityAdmin)
Pour créer un projet (facultatif) : Créateur de projet (roles/resourcemanager.projectCreator)

Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

Générer une clé et des certificats signés

Cette section utilise les commandes openssl pour créer un certificat racine et un certificat intermédiaire.

Utilisez les commandes suivantes pour générer un certificat racine et un certificat intermédiaire signé avec des champs keyUsage et extendedKeyUsage valides.

Créez un exemple de fichier example.cnf avec la configuration minimale requise pour créer des certificats de signature valides. Vous pouvez modifier ce fichier si vous souhaitez définir d'autres champs pour ces certificats.

cat > example.cnf << EOF
[req]
distinguished_name = empty_distinguished_name
[empty_distinguished_name]
# Kept empty to allow setting via -subj command line arg.
[ca_exts]
basicConstraints=critical,CA:TRUE
keyUsage=keyCertSign
extendedKeyUsage=clientAuth
EOF

Créez le certificat racine.

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

Créez la requête de signature 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

Créez le certificat intermédiaire.

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

Générer un certificat ajouté à la liste d'autorisation

Cette section utilise les commandes openssl pour créer un exemple de certificat ajouté à la liste d'autorisation.

Utilisez les commandes suivantes pour générer un certificat ajouté à la liste d'autorisation.

   openssl req -x509 \
       -new -sha256 -newkey rsa:2048 -nodes \
       -days 3650 -subj '/CN=localhost' \
       -keyout allowlisted.key -out allowlisted.cert

Mettre en forme les certificats

Pour inclure de nouveaux certificats ou des certificats existants dans un TrustStore, définissez une mise en forme de ces certificats sur une seule ligne et stockez-les dans des variables d'environnement, afin qu'ils puissent être lus dans le fichier YAML. Utilisez les commandes suivantes pour mettre en forme les certificats et les stocker dans des variables d'environnement :

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')

Pour inclure de nouveaux certificats ou des certificats existants dans un truststore, définissez une mise en forme de ces certificats sur une seule ligne et stockez-les dans des variables d'environnement, afin qu'ils puissent être lus dans le fichier YAML. Utilisez les commandes suivantes pour mettre en forme les certificats ajoutés à la liste d'autorisation et les stocker dans des variables d'environnement :

export ALLOWLISTED_CERT=$(cat allowlisted.cert | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

Créer une ressource TrustConfig

Créez une ressource de gestionnaire de certificats TrustConfig qui représente votre PKI. Cet exemple de ressource TrustConfig contient un truststore avec deux ancres de confiance et deux certificats CA intermédiaires. Il lit le contenu du certificat à partir des variables d'environnement créées à l'étape précédente, Mettre en forme les certificats.

Pour créer un truststore avec d'autres ancres de confiance ou d'autres certificats CA intermédiaires, ajoutez des lignes pemCertificate dans la section appropriée. Si vous avez moins d'ancres de confiance ou de certificats CA intermédiaires que de lignes disponibles, supprimez les lignes inutiles.

Cet exemple de ressource TrustConfig contient un certificat ajouté à la liste d'autorisation. Vous pouvez spécifier plusieurs certificats ajoutés à la liste d'autorisation en utilisant plusieurs instances du champ pemCertificate.

Dans les étapes suivantes, remplacez TRUST_CONFIG_NAME par le nom de la ressource TrustConfig :

Pour créer le fichier trust_config.yaml avec un magasin de confiance, utilisez la commande suivante :

cat << EOF > trust_config.yaml
trustStores:
- trustAnchors:
  - pemCertificate: "${ROOT_CERT?}"
  - pemCertificate: "${ROOT_CERT_2?}"
  intermediateCas:
  - pemCertificate: "${INTERMEDIATE_CERT?}"
  - pemCertificate: "${INTERMEDIATE_CERT_2?}"
EOF

Facultatif: pour créer le fichier trust_config.yaml avec un certificat ajouté à la liste d'autorisation, exécutez la commande suivante :
```
cat << EOF > trust_config.yaml
 allowlistedCertificates:
 - pemCertificate: "${ALLOWLISTED_CERT?}"
EOF
```
Pour créer les ressources TrustConfig du gestionnaire de certificats, utilisez la commande gcloud certificate-manager trust-configs import :
global
Pour les équilibreurs de charge d'application externes et les équilibreurs de charge d'application internes interrégionaux, utilisez la commande suivante :
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME  \
   --source=trust_config.yaml
```
régional
Pour les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux, utilisez la commande suivante :
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME  \
   --source=trust_config.yaml \
   --location=REGION
```

Créer les ressources de sécurité réseau

Une règle TLS de serveur (ressource de sécurité réseau ServerTLSPolicy) vous permet de spécifier le mode TLS côté serveur et la ressource TrustConfig à utiliser lors de la validation des certificats clients. Lorsque le client présente un certificat non valide ou aucun certificat à l'équilibreur de charge, clientValidationMode spécifie la manière dont la connexion client est gérée.

Lorsque clientValidationMode est défini sur ALLOW_INVALID_OR_MISSING_CLIENT_CERT, toutes les requêtes sont transmises au backend même si la validation échoue ou si le certificat client est manquant.
Lorsque clientValidationMode est défini sur REJECT_INVALID, seules les requêtes fournissant un certificat client pouvant être validé sur une ressource TrustConfig sont transmises au backend.

Pour créer la ressource ServerTLSPolicy, procédez comme suit :

Selon la manière dont vous souhaitez gérer la connexion, sélectionnez l'une des options suivantes.

Dans les étapes suivantes, remplacez SERVER_TLS_POLICY_NAME par le nom de la règle TLS du serveur et PROJECT_ID par l'ID de votre projet Google Cloud.
- Option 1 : clientValidationMode est défini sur ALLOW_INVALID_OR_MISSING_CLIENT_CERT.
  
  Pour créer le fichier server_tls_policy.yaml, exécutez la commande suivante :
  global
  Pour les équilibreurs de charge d'application externes et les équilibreurs de charge d'application internes interrégionaux, utilisez la commande suivante :
```
cat << EOF > server_tls_policy.yaml
name: SERVER_TLS_POLICY_NAME
mtlsPolicy:
  clientValidationMode: ALLOW_INVALID_OR_MISSING_CLIENT_CERT
  clientValidationTrustConfig: projects/PROJECT_ID/locations/global/trustConfigs/TRUST_CONFIG_NAME
EOF
```
  régional
  Pour les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux, utilisez la commande suivante :
```
cat << EOF > server_tls_policy.yaml
name: SERVER_TLS_POLICY_NAME
mtlsPolicy:
  clientValidationMode: ALLOW_INVALID_OR_MISSING_CLIENT_CERT
  clientValidationTrustConfig: projects/PROJECT_ID/locations/REGION/trustConfigs/TRUST_CONFIG_NAME
EOF
```
- Option 2 : clientValidationMode est défini sur REJECT_INVALID.
  
  Pour créer le fichier server_tls_policy.yaml, exécutez la commande suivante :
  global
  Pour les équilibreurs de charge d'application externes et les équilibreurs de charge d'application internes interrégionaux, utilisez la commande suivante :
```
cat << EOF > server_tls_policy.yaml
name: SERVER_TLS_POLICY_NAME
mtlsPolicy:
  clientValidationMode: REJECT_INVALID
  clientValidationTrustConfig: projects/PROJECT_ID/locations/global/trustConfigs/TRUST_CONFIG_NAME
EOF
```
  régional
  Pour les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux, utilisez la commande suivante :
```
cat << EOF > server_tls_policy.yaml
name: SERVER_TLS_POLICY_NAME
mtlsPolicy:
  clientValidationMode: REJECT_INVALID
  clientValidationTrustConfig: projects/PROJECT_ID/locations/REGION/trustConfigs/TRUST_CONFIG_NAME
EOF
```
Pour créer la ressource ServerTlsPolicy, utilisez la commande gcloud network-security server-tls-policies import.
global
Pour les équilibreurs de charge d'application externes et les équilibreurs de charge d'application internes interrégionaux, utilisez la commande suivante :
```
gcloud network-security server-tls-policies import SERVER_TLS_POLICY_NAME \
  --source=server_tls_policy.yaml \
  --location=global
```
régional
Pour les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux, utilisez la commande suivante :
```
gcloud network-security server-tls-policies import SERVER_TLS_POLICY_NAME \
  --source=server_tls_policy.yaml \
  --location=REGION
```

Pour en savoir plus, consultez la section Modes de validation des clients MTLS.

Signer une clé client avec le certificat intermédiaire

Cette section fournit une option de configuration supplémentaire pour générer un certificat d'entité finale. Si vous avez déjà créé une ressource TrustConfig à l'aide de certificats intermédiaires (int.cert et int.key), procédez comme suit :

Créez un fichier de configuration de clé client.

cat > client.config << EOF
[req]
default_bits              = 2048
req_extensions            = extension_requirements
distinguished_name        = dn_requirements
prompt                    = no

[extension_requirements]
basicConstraints          = critical, CA:FALSE
keyUsage                  = critical, nonRepudiation, digitalSignature, keyEncipherment
extendedKeyUsage          = clientAuth

[dn_requirements]
countryName               = US
stateOrProvinceName       = California
localityName              = San Francisco
0.organizationName        = example
organizationalUnitName    = test
commonName                = test.example.com
emailAddress              = test@example.com

EOF

Si vous souhaitez associer une identité SPIFFE :

Ajoutez un subjectAltName à votre section [extension_requirements] comme suit :
```
subjectAltName            = @sans_list
```

Ajoutez une section au bas du fichier client.config avec ce qui suit :

[sans_list]
URI.1                     = spiffe://example.com/test-identity

Signez la clé.

openssl req -new -keyout client.key -out client.csr -config client.config

openssl x509 -req -in client.csr -out client.cert -extfile client.config -extensions extension_requirements -days 365 -CA int.cert -CAkey int.key

Pour effectuer un test, envoyez une requête curl à l'adresse IP de l'équilibreur de charge.
```
curl -v -k --key client.key --cert client.cert https://IP_ADDRESS
```
Remplacez IP_ADDRESS par l'adresse IP de l'équilibreur de charge.

Configurer un protocole TLS mutuel avec des certificats fournis par l'utilisateur

Avant de commencer

gcloud

Autorisations

Générer une clé et des certificats signés

Générer un certificat ajouté à la liste d'autorisation

Mettre en forme les certificats

Créer une ressource TrustConfig

global

régional

Créer les ressources de sécurité réseau

global

régional

global

régional

global

régional

Signer une clé client avec le certificat intermédiaire

Étapes suivantes