Créer une autorité de certification subordonnée

Cette page explique comment créer des autorités de certification subordonnées (CA) dans un pool d'autorités de certification.

Les autorités de certification subordonnées sont responsables de l'émission de certificats directement aux entités finales telles que les utilisateurs, les ordinateurs et les appareils. Les autorités de certification subordonnées sont signées de manière cryptographique par une autorité de certification parente, qui est souvent l'autorité de certification racine. Par conséquent, les systèmes qui font confiance à l'autorité de certification racine approuvent automatiquement les autorités de certification subordonnées et les certificats d'entité finale qu'elles émettent.

Avant de commencer

• Assurez-vous de disposer du rôle IAM "CA Service Operation Manager" (roles/privateca.caManager) ou le rôle IAM "CA Service Admin" (roles/privateca.admin). Pour en savoir plus, consultez la page Configurer des stratégies IAM.
• Créez un pool d'autorités de certification.
• Sélectionnez votre autorité de certification racine.

Créer une autorité de certification subordonnée

Les autorités de certification subordonnées sont plus faciles à révoquer et à alterner que les autorités de certification racine. Si vous disposez de plusieurs scénarios d'émission de certificats, vous pouvez créer une autorité de certification subordonnée pour chacun d'entre eux. L'ajout de plusieurs autorités de certification subordonnées dans un pool d'autorités de certification vous aide à mieux équilibrer la charge des requêtes de certificat et à augmenter le nombre total de RPS effectifs.

Pour créer une autorité de certification subordonnée, procédez comme suit:

Console

1. Accédez à la page Certificate Authority Service de la console Google Cloud.

   Accéder à Certificate Authority Service

2. Cliquez sur l'onglet Gestionnaire de CA.

3. Cliquez sur Créer une autorité de certification.

   

Sélectionner le type d'autorité de certification

1. Cliquez sur Autorité de certification subordonnée.
2. Cliquez sur L'autorité de certification racine est dans Google Cloud.
3. Dans le champ Valide pour, saisissez la durée pendant laquelle vous souhaitez que le certificat CA soit valide.
4. Facultatif: choisissez le niveau de l'autorité de certification. Le niveau par défaut est Enterprise. Pour en savoir plus, consultez la section Sélectionner les niveaux d'opérations.
5. Cliquez sur Région afin de sélectionner un emplacement pour l'autorité de certification. Pour plus d'informations, consultez la section Emplacements.
6. Facultatif: Sous État initial, sélectionnez l'état dans lequel l'autorité de certification doit se trouver lors de la création.
7. Facultatif: Sous Configurer un scénario d'émission, cliquez sur Profil de certificat, puis sélectionnez dans la liste le profil de certificat qui répond le mieux à vos besoins. Pour en savoir plus, consultez la section Profils de certificat.
8. Cliquez sur Suivant.

Configurer le nom d'objet de l'autorité de certification

1. Dans le champ Organisation (O), saisissez le nom de votre entreprise.
2. Facultatif: dans le champ Unité organisationnelle (UO), saisissez la subdivision de l'entreprise ou l'unité commerciale.
3. Facultatif: Dans le champ Nom du pays, saisissez un code de pays à deux lettres.
4. Facultatif: dans le champ Nom de l'État ou de la province, saisissez le nom de votre État.
5. Facultatif: dans le champ Nom de la localité, saisissez le nom de votre ville.
6. Dans le champ Nom commun de l'autorité de certification (CN), saisissez le nom de l'autorité de certification.
7. Dans le champ ID du pool, saisissez le nom du pool d'autorités de certification. Vous ne pouvez pas modifier le pool d'autorités de certification après avoir créé l'autorité de certification.
8. Cliquez sur Suivant.

Configurer l'algorithme et la taille de clé de l'autorité de certification

1. Choisissez l'algorithme de clé qui répond le mieux à vos besoins. Pour en savoir plus sur le choix de l'algorithme de clé approprié, consultez Choisir un algorithme de clé.
2. Cliquez sur Suivant.

Configurer les artefacts d'autorité de certification

Les étapes suivantes sont facultatives. Si vous ignorez ces étapes, les paramètres par défaut s'appliquent.

1. Indiquez si vous souhaitez utiliser un bucket Cloud Storage géré par Google ou autogéré.

Si vous ne sélectionnez pas de bucket Cloud Storage autogéré, CA Service crée un bucket géré par Google au même emplacement que l'autorité de certification.

2. Indiquez si vous souhaitez désactiver la publication des listes de révocation de certificats (LRC) et des certificats CA dans le bucket Cloud Storage.

La publication de certificats LRC et CA sur un bucket Cloud Storage est activée par défaut. Pour désactiver ces paramètres, cliquez sur les boutons d'activation.

3. Cliquez sur Suivant.

Ajouter des étiquettes

Les étapes suivantes sont facultatives.

Si vous souhaitez ajouter des étiquettes à l'autorité de certification, procédez comme suit:

1. Cliquez sur Ajouter un élément.
2. Dans le champ Clé 1, saisissez la clé de libellé.
3. Dans le champ Valeur 1, saisissez la valeur du libellé.
4. Si vous souhaitez ajouter un autre libellé, cliquez sur Ajouter un élément. Ajoutez ensuite la clé et la valeur de libellé, comme indiqué aux étapes 2 et 3.
5. Cliquez sur Suivant.

Examiner les paramètres

Examinez attentivement tous les paramètres, puis cliquez sur Créer pour créer l'autorité de certification.

gcloud

1. Créez un pool d'autorités de certification pour l'autorité de certification subordonnée:

   gcloud privateca pools create SUBORDINATE_POOL_ID
   

   Remplacez SUBORDINATE_POOL_ID par le nom du pool d'autorités de certification.

   Pour en savoir plus sur la création de pools d'autorités de certification, consultez la page Créer un pool d'autorités de certification.

   Pour plus d'informations sur la commande gcloud privateca pools create, consultez la page gcloud privateca pools create.

2. Créez une autorité de certification subordonnée dans le pool d'autorités de certification créé.

   Remarque :Vous pouvez obtenir l'ID de ressource de l'émetteur (POOL_ID) en le copiant à partir de la commande "create" ou en exécutant la commande gcloud privateca pools list.

   gcloud privateca subordinates create SUBORDINATE_CA_ID \
     --pool=SUBORDINATE_POOL_ID \
     --issuer-pool=POOL_ID \
     --key-algorithm="ec-p256-sha256" \
     --subject="CN=Example Server TLS CA, O=Example LLC"
   

   L'instruction suivante est renvoyée lors de la création de l'autorité de certification subordonnée.

   Created Certificate Authority [projects/my-project-pki/locations/us-west1/caPools/SUBORDINATE_POOL_ID/certificateAuthorities/SUBORDINATE_CA_ID].
   

   Pour afficher la liste complète des paramètres, exécutez la commande gcloud suivante:

   gcloud privateca subordinates create --help
   

   La commande renvoie des exemples pour créer une autorité de certification subordonnée dont l'émetteur est situé sur le service d'autorité de certification ou ailleurs.

Terraform

resource "google_privateca_certificate_authority" "root_ca" {
  pool                                   = "my-pool"
  certificate_authority_id               = "my-certificate-authority-root"
  location                               = "us-central1"
  deletion_protection                    = false # set to true to prevent destruction of the resource
  ignore_active_certificates_on_deletion = true
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        # is_ca *MUST* be true for certificate authorities
        is_ca = true
      }
      key_usage {
        base_key_usage {
          # cert_sign and crl_sign *MUST* be true for certificate authorities
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
          server_auth = false
        }
      }
    }
  }
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}

resource "google_privateca_certificate_authority" "default" {
  // This example assumes this pool already exists.
  // Pools cannot be deleted in normal test circumstances, so we depend on static pools
  pool                     = "my-pool"
  certificate_authority_id = "my-certificate-authority-sub"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  subordinate_config {
    certificate_authority = google_privateca_certificate_authority.root_ca.name
  }
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-subordinate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        is_ca = true
        # Force the sub CA to only issue leaf certs
        max_issuer_path_length = 0
      }
      key_usage {
        base_key_usage {
          digital_signature  = true
          content_commitment = true
          key_encipherment   = false
          data_encipherment  = true
          key_agreement      = true
          cert_sign          = true
          crl_sign           = true
          decipher_only      = true
        }
        extended_key_usage {
          server_auth      = true
          client_auth      = false
          email_protection = true
          code_signing     = true
          time_stamping    = true
        }
      }
    }
  }
  lifetime = "86400s"
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
  type = "SUBORDINATE"
}

Java

Pour vous authentifier auprès du service CA, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.CertificateAuthority;
import com.google.cloud.security.privateca.v1.CertificateAuthority.KeyVersionSpec;
import com.google.cloud.security.privateca.v1.CertificateAuthority.SignHashAlgorithm;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.CertificateConfig;
import com.google.cloud.security.privateca.v1.CertificateConfig.SubjectConfig;
import com.google.cloud.security.privateca.v1.CreateCertificateAuthorityRequest;
import com.google.cloud.security.privateca.v1.KeyUsage;
import com.google.cloud.security.privateca.v1.KeyUsage.KeyUsageOptions;
import com.google.cloud.security.privateca.v1.Subject;
import com.google.cloud.security.privateca.v1.SubjectAltNames;
import com.google.cloud.security.privateca.v1.X509Parameters;
import com.google.cloud.security.privateca.v1.X509Parameters.CaOptions;
import com.google.longrunning.Operation;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateSubordinateCa {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: Set it to the CA Pool under which the CA should be created.
    // subordinateCaName: Unique name for the Subordinate CA.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String subordinateCaName = "subordinate-certificate-authority-name";

    createSubordinateCertificateAuthority(project, location, poolId, subordinateCaName);
  }

  public static void createSubordinateCertificateAuthority(
      String project, String location, String poolId, String subordinateCaName)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `certificateAuthorityServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {

      String commonName = "commonname";
      String orgName = "csr-org-name";
      String domainName = "dns.example.com";
      int caDuration = 100000; // Validity of this CA in seconds.

      // Set the type of Algorithm.
      KeyVersionSpec keyVersionSpec =
          KeyVersionSpec.newBuilder().setAlgorithm(SignHashAlgorithm.RSA_PKCS1_4096_SHA256).build();

      // Set CA subject config.
      SubjectConfig subjectConfig =
          SubjectConfig.newBuilder()
              .setSubject(
                  Subject.newBuilder().setCommonName(commonName).setOrganization(orgName).build())
              // Set the fully qualified domain name.
              .setSubjectAltName(SubjectAltNames.newBuilder().addDnsNames(domainName).build())
              .build();

      //  Set the key usage options for X.509 fields.
      X509Parameters x509Parameters =
          X509Parameters.newBuilder()
              .setKeyUsage(
                  KeyUsage.newBuilder()
                      .setBaseKeyUsage(
                          KeyUsageOptions.newBuilder().setCrlSign(true).setCertSign(true).build())
                      .build())
              .setCaOptions(CaOptions.newBuilder().setIsCa(true).build())
              .build();

      // Set certificate authority settings.
      CertificateAuthority subCertificateAuthority =
          CertificateAuthority.newBuilder()
              .setType(CertificateAuthority.Type.SUBORDINATE)
              .setKeySpec(keyVersionSpec)
              .setConfig(
                  CertificateConfig.newBuilder()
                      .setSubjectConfig(subjectConfig)
                      .setX509Config(x509Parameters)
                      .build())
              // Set the CA validity duration.
              .setLifetime(Duration.newBuilder().setSeconds(caDuration).build())
              .build();

      // Create the CertificateAuthorityRequest.
      CreateCertificateAuthorityRequest subCertificateAuthorityRequest =
          CreateCertificateAuthorityRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateAuthorityId(subordinateCaName)
              .setCertificateAuthority(subCertificateAuthority)
              .build();

      // Create Subordinate CA.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .createCertificateAuthorityCallable()
              .futureCall(subCertificateAuthorityRequest);

      Operation response = futureCall.get();

      if (response.hasError()) {
        System.out.println("Error while creating Subordinate CA !" + response.getError());
        return;
      }

      System.out.println(
          "Subordinate Certificate Authority created successfully : " + subordinateCaName);
    }
  }
}

Python

Pour vous authentifier auprès du service CA, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

import google.cloud.security.privateca_v1 as privateca_v1
from google.protobuf import duration_pb2

def create_subordinate_ca(
    project_id: str,
    location: str,
    ca_pool_name: str,
    subordinate_ca_name: str,
    common_name: str,
    organization: str,
    domain: str,
    ca_duration: int,
) -> None:
    """
    Create Certificate Authority (CA) which is the subordinate CA in the given CA Pool.
    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        location: location you want to use. For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
        ca_pool_name: set it to the CA Pool under which the CA should be created.
        subordinate_ca_name: unique name for the Subordinate CA.
        common_name: a title for your certificate authority.
        organization: the name of your company for your certificate authority.
        domain: the name of your company for your certificate authority.
        ca_duration: the validity of the certificate authority in seconds.
    """

    ca_service_client = privateca_v1.CertificateAuthorityServiceClient()

    # Set the type of Algorithm
    key_version_spec = privateca_v1.CertificateAuthority.KeyVersionSpec(
        algorithm=privateca_v1.CertificateAuthority.SignHashAlgorithm.RSA_PKCS1_4096_SHA256
    )

    # Set CA subject config.
    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(
            common_name=common_name, organization=organization
        ),
        # Set the fully qualified domain name.
        subject_alt_name=privateca_v1.SubjectAltNames(dns_names=[domain]),
    )

    # Set the key usage options for X.509 fields.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                crl_sign=True,
                cert_sign=True,
            )
        ),
        ca_options=privateca_v1.X509Parameters.CaOptions(
            is_ca=True,
        ),
    )

    # Set certificate authority settings.
    certificate_authority = privateca_v1.CertificateAuthority(
        type_=privateca_v1.CertificateAuthority.Type.SUBORDINATE,
        key_spec=key_version_spec,
        config=privateca_v1.CertificateConfig(
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        # Set the CA validity duration.
        lifetime=duration_pb2.Duration(seconds=ca_duration),
    )

    ca_pool_path = ca_service_client.ca_pool_path(project_id, location, ca_pool_name)

    # Create the CertificateAuthorityRequest.
    request = privateca_v1.CreateCertificateAuthorityRequest(
        parent=ca_pool_path,
        certificate_authority_id=subordinate_ca_name,
        certificate_authority=certificate_authority,
    )

    operation = ca_service_client.create_certificate_authority(request=request)
    result = operation.result()

    print(f"Operation result: {result}")

Activer une autorité de certification subordonnée

Pour activer une autorité de certification subordonnée, procédez comme suit:

Console

1. Accédez à la page Certificate Authority Service de la console Google Cloud.

   Accéder à Certificate Authority Service

2. Cliquez sur l'onglet Gestionnaire de CA.

3. Sous Autorités de certification, sélectionnez l'autorité de certification que vous souhaitez activer.

4. Cliquez sur Activer.

5. Dans la boîte de dialogue qui s'ouvre, cliquez sur Télécharger la requête de signature de certificat pour télécharger le fichier de requête de signature de certificat encodé au format PEM que l'autorité de certification émettrice peut signer.

6. Cliquez sur Suivant.

7. Dans le champ Importer la chaîne de certificats, cliquez sur Parcourir.

8. Importez le fichier de certificat signé avec l'extension .crt.

9. Cliquez sur Activer.

gcloud

Pour activer une autorité de certification subordonnée nouvellement créée, exécutez la commande suivante:

gcloud privateca subordinates enable SUBORDINATE_CA_ID --pool=SUBORDINATE_POOL_ID

Remplacez les éléments suivants :

• SUBORDINATE_CA_ID: identifiant unique de l'autorité de certification subordonnée.
• SUBORDINATE_POOL_ID: nom du pool d'autorités de certification qui contient l'autorité de certification subordonnée.

Pour plus d'informations sur la commande gcloud privateca subordinates enable, consultez la section gcloud privateca suborinates enable.

Terraform

Définissez le champ desired_state sur ENABLED sur l'autorité de certification subordonnée et exécutez terraform apply.

Remarque :CA Service ne vérifie pas l'état de révocation de l'autorité de certification racine avant d'activer une autorité de certification subordonnée qui y est reliée. La seule exception à cette règle est lorsque vous avez créé l'autorité de certification racine à l'aide du service CA. Dans ce scénario, CA Service vérifie quotidiennement l'état de révocation de l'autorité de certification racine. Si l'autorité de certification racine est révoquée, CA Service met à jour la métrique privateca.googleapis.com/ca/cert_revoked sur l'autorité de certification subordonnée.

Étapes suivantes

• Découvrez comment demander des certificats.
• En savoir plus sur les modèles et les règles d'émission