Demander un certificat et afficher les certificats émis

Cet article explique comment demander un certificat auprès de Certificate Authority Service et afficher les certificats émis.

Avant de commencer

Assurez-vous de disposer du rôle IAM "Demandeur de certificats du service CA (roles/privateca.certificateRequester) ou "Gestionnaire de certificats du service CA" (roles/privateca.certificateManager). Pour en savoir plus sur les rôles IAM prédéfinis pour le service de CA, consultez la page Contrôle des accès avec IAM.

Pour en savoir plus sur l'attribution d'un rôle IAM à un compte principal, consultez Attribuer un seul rôle.

Présentation

Vous pouvez demander un certificat à l'aide des méthodes suivantes:

Générez votre propre clé privée ou publique, puis envoyez une demande de signature de certificat (CSR).
Demandez à CA Service de créer une clé privée ou publique.
Utiliser une clé Cloud Key Management Service (Cloud KMS) existante

Demander un certificat à l'aide d'une requête de signature de certificat

Avant de continuer, vous devez générer une requête de signature de certificat. Après avoir généré une requête de signature de certificat, procédez comme suit:

Console

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

Accéder à Certificate Authority Service
Cliquez sur l'onglet Gestionnaire de CA.
Cliquez sur le nom de l'autorité de certification depuis laquelle vous souhaitez délivrer.
Au bas de la page "Détails de l'autorité de certification", cliquez sur Demander un certificat.
Facultatif: Si vous souhaitez utiliser un modèle de certificat, cliquez sur , sélectionnez un modèle dans la liste, puis cliquez sur Enregistrer.
Cliquez sur Fournir la requête de signature de certificat.
Facultatif: Pour écraser le nom du certificat généré automatiquement, saisissez le nom personnalisé dans le champ Nom du certificat.
Facultatif: Pour choisir une période de validité personnalisée pour le certificat, saisissez la valeur dans le champ Valide pour.
Copiez et collez votre requête de signature de certificat dans la zone CSR du certificat. Pour importer la requête de signature de certificat, cliquez sur Parcourir.
Cliquez sur Suivant.

Télécharger le certificat signé

Pour copier le certificat, cliquez sur . Pour télécharger le certificat sous la forme d'un fichier .crt, cliquez sur Télécharger le certificat.
Facultatif: Pour télécharger la chaîne de certificats, cliquez sur Télécharger la chaîne de certificats.
Cliquez sur OK.

gcloud

gcloud privateca certificates create CERT_ID \
     --issuer-pool POOL_ID \
     --csr CSR_FILENAME \
     --cert-output-file CERT_FILENAME \
     --validity "P30D"

Remplacez les éléments suivants :

CERT_ID: identifiant unique du certificat.
POOL_ID: nom du pool d'autorités de certification.
CSR_FILENAME: fichier qui stocke la requête de signature de certificat encodée au format PEM.

L'option --validity définit la durée de validité du certificat. Il s'agit d'un indicateur facultatif dont la valeur par défaut est de 30 jours.

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

Terraform

resource "google_privateca_certificate_authority" "test_ca" {
  pool                     = "my-pool"
  certificate_authority_id = "my-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  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" "default" {
  pool                  = "my-pool"
  location              = "us-central1"
  certificate_authority = google_privateca_certificate_authority.test_ca.certificate_authority_id
  lifetime              = "860s"
  name                  = "my-certificate"
  pem_csr               = tls_cert_request.example.cert_request_pem
}

resource "tls_private_key" "example" {
  algorithm = "RSA"
}

resource "tls_cert_request" "example" {
  private_key_pem = tls_private_key.example.private_key_pem

  subject {
    common_name  = "example.com"
    organization = "ACME Examples, Inc"
  }
}

API REST

Générez une demande de signature de certificat (CSR) à l'aide de la méthode de votre choix, par exemple openssl.

Voici un exemple de requête de signature de certificat encodée pour le format JSON.

Demandez un certificat.

Méthode HTTP et URL :
```
POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID
```
Corps JSON de la requête :
```
{
 "lifetime": {
   "seconds": 3600,
   "nanos": 0
 },
 "pem_csr": "PEM_CSR"
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json et exécutez la commande suivante:
```
curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID"
```
PowerShell (Windows)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json et exécutez la commande suivante:
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID" | Select-Object -Expand Content
```
Vous devriez recevoir une réponse JSON de ce type :
```
{
 "name": "projects/project-id/locations/location/certificateAuthorities/ca-id/certificates/certificate-id",
 "pemCertificate": "-----BEGIN CERTIFICATE-----...",
 "certificateDescription": {...}
}
```
Attention :Nous vous recommandons de ne pas émettre de certificats d'entité de fin à partir d'une autorité de certification racine. Pour en savoir plus sur la création d'autorités de certification subordonnées, consultez la page Créer des autorités de certification.

Demander un certificat à l'aide d'une clé générée automatiquement

Console

Vous pouvez utiliser la console Google Cloud pour générer des certificats TLS client ou serveur.

Dans la console Google Cloud, accédez à la page Certificate Authority Service.

Accéder à Certificate Authority Service
Cliquez sur l'onglet Gestionnaire de CA.
Cliquez sur le nom de l'autorité de certification depuis laquelle vous souhaitez délivrer.
Au bas de la page d'informations de l'autorité de certification, cliquez sur Demander un certificat.
Facultatif: Si vous souhaitez utiliser un modèle de certificat, cliquez sur , sélectionnez un modèle dans la liste, puis cliquez sur Enregistrer.
Cliquez sur Saisir les détails.
Facultatif: Remplacez le nom du certificat généré automatiquement par un nom personnalisé et unique.
Facultatif: Pour choisir une période de validité personnalisée pour le certificat, saisissez la valeur dans le champ Valide pour.

Ajouter un nom de domaine

Sous Add domain name (Ajouter un nom de domaine), saisissez un nom de domaine dans le champ Domain name 1 (Nom de domaine 1).
Facultatif: si vous souhaitez ajouter plusieurs noms de domaine, cliquez sur Add Item (Ajouter un élément), puis saisissez un autre nom de domaine dans le champ Domain name 2 (Nom de domaine 2).

Utilisation étendue des clés

Facultatif: Sous Utilisation étendue des clés, sélectionnez l'une des options suivantes en fonction de votre cas d'utilisation:
- TLS serveur: ces certificats vous permettent d'authentifier l'identité d'un serveur.
- TLS client: ces certificats vous permettent d'authentifier l'identité d'un demandeur.
Cliquez sur Suivant.

Configurer l'algorithme et la taille de la clé

Facultatif: Sous Configurer la taille de la clé et l'algorithme, sélectionnez l'algorithme et la taille de la clé de signature dans la liste. Si vous ignorez cette étape, une clé RSAASSA-PSS de 2 048 bits avec un condensé SHA 256 est utilisée. Pour en savoir plus sur la sélection d'une clé et d'un algorithme de signature, consultez Choisir un algorithme de clé.
Cliquez sur Continuer.

Télécharger le certificat signé

Facultatif: Pour télécharger la chaîne de certificats encodée au format PEM, cliquez sur Télécharger la chaîne de certificats.
Facultatif: Pour télécharger la clé privée associée encodée au format PEM, cliquez sur Télécharger la clé privée.

Important :Vous ne pouvez pas récupérer cette clé après avoir quitté cette page. Cette clé est sensible. Nous vous recommandons de protéger la clé dans un emplacement sécurisé.
Cliquez sur OK.

Important :Si vous utilisez un pool d'autorités de certification DevOps, c'est le seul moment où vous pouvez télécharger le certificat créé. CA Service ne stocke pas le contenu du certificat au-delà de cet écran.

gcloud

Pour utiliser la fonctionnalité de clé générée automatiquement, vous devez installer la bibliothèque Python Cryptographic Authority (PyCA). Pour obtenir des instructions sur l'installation de la bibliothèque de cryptographie Pyca, consultez l'article Inclure la bibliothèque de cryptographie Pyca.

Pour créer un certificat, exécutez la commande gcloud suivante:

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --generate-key \
  --key-output-file KEY_FILENAME \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "CERTIFICATE_PROFILE"

Remplacez les éléments suivants :

POOL_ID: nom du pool d'autorités de certification.
KEY_FILENAME: chemin d'accès où le fichier de clé privée généré doit être écrit.
CERT_FILENAME: chemin d'accès où le fichier de chaîne de certificat encodé au format PEM doit être écrit. La chaîne de certificats est triée de l'entité finale à la racine.
DNS_NAME: un ou plusieurs noms d'objet alternatifs (SAN) DNS séparés par une virgule.
CERTIFICATE_PROFILE: identifiant unique du profil de certificat. Par exemple, utilisez leaf_server_tls pour le protocole TLS du serveur d'entité finale.

La commande gcloud mentionne les options suivantes:

--generate-key: génère une nouvelle clé privée RSA-2048 sur votre machine.

Vous pouvez également utiliser n'importe quelle combinaison des options suivantes:

--dns-san: permet de transmettre un ou plusieurs SAN DNS séparés par une virgule.
--ip-san: permet de transmettre un ou plusieurs SAN IP séparés par une virgule.
--uri-san: permet de transmettre un ou plusieurs SAN d'URI séparés par une virgule.
--subject: permet de transmettre un nom X.501 du sujet du certificat.

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

Go

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 (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
	"google.golang.org/protobuf/types/known/durationpb"
)

// Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
// The key used to sign the certificate is created by the Cloud KMS.
func createCertificate(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string,
	caId string,
	certId string,
	commonName string,
	domainName string,
	certDuration int64,
	publicKeyBytes []byte) error {
	// projectId := "your_project_id"
	// location := "us-central1"		// For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
	// caPoolId := "ca-pool-id"			// The CA Pool id in which the certificate authority exists.
	// caId := "ca-id"					// The name of the certificate authority which issues the certificate.
	// certId := "certificate"			// A unique name for the certificate.
	// commonName := "cert-name"		// A common name for the certificate.
	// domainName := "cert.example.com"	// Fully qualified domain name for the certificate.
	// certDuration := int64(31536000)	// The validity of the certificate in seconds.
	// publicKeyBytes 					// The public key used in signing the certificates.

	ctx := context.Background()
	caClient, err := privateca.NewCertificateAuthorityClient(ctx)
	if err != nil {
		return fmt.Errorf("NewCertificateAuthorityClient creation failed: %w", err)
	}
	defer caClient.Close()

	// Set the Public Key and its format.
	publicKey := &privatecapb.PublicKey{
		Key:    publicKeyBytes,
		Format: privatecapb.PublicKey_PEM,
	}

	// Set Certificate subject config.
	subjectConfig := &privatecapb.CertificateConfig_SubjectConfig{
		Subject: &privatecapb.Subject{
			CommonName: commonName,
		},
		SubjectAltName: &privatecapb.SubjectAltNames{
			DnsNames: []string{domainName},
		},
	}

	// Set the X.509 fields required for the certificate.
	x509Parameters := &privatecapb.X509Parameters{
		KeyUsage: &privatecapb.KeyUsage{
			BaseKeyUsage: &privatecapb.KeyUsage_KeyUsageOptions{
				DigitalSignature: true,
				KeyEncipherment:  true,
			},
			ExtendedKeyUsage: &privatecapb.KeyUsage_ExtendedKeyUsageOptions{
				ServerAuth: true,
				ClientAuth: true,
			},
		},
	}

	// Set certificate settings.
	cert := &privatecapb.Certificate{
		CertificateConfig: &privatecapb.Certificate_Config{
			Config: &privatecapb.CertificateConfig{
				PublicKey:     publicKey,
				SubjectConfig: subjectConfig,
				X509Config:    x509Parameters,
			},
		},
		Lifetime: &durationpb.Duration{
			Seconds: certDuration,
		},
	}

	fullCaPoolName := fmt.Sprintf("projects/%s/locations/%s/caPools/%s", projectId, location, caPoolId)

	// Create the CreateCertificateRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#CreateCertificateRequest.
	req := &privatecapb.CreateCertificateRequest{
		Parent:                        fullCaPoolName,
		CertificateId:                 certId,
		Certificate:                   cert,
		IssuingCertificateAuthorityId: caId,
	}

	_, err = caClient.CreateCertificate(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateCertificate failed: %w", err)
	}

	fmt.Fprintf(w, "Certificate %s created", certId)

	return nil
}

Java


import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.Certificate;
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.CreateCertificateRequest;
import com.google.cloud.security.privateca.v1.KeyUsage;
import com.google.cloud.security.privateca.v1.KeyUsage.ExtendedKeyUsageOptions;
import com.google.cloud.security.privateca.v1.KeyUsage.KeyUsageOptions;
import com.google.cloud.security.privateca.v1.PublicKey;
import com.google.cloud.security.privateca.v1.PublicKey.KeyFormat;
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.protobuf.ByteString;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateCertificate {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.

    // publicKeyBytes: Public key used in signing the certificates.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: Set a unique id for the CA pool.
    // certificateAuthorityName: The name of the certificate authority which issues the certificate.
    // certificateName: Set a unique name for the certificate.
    String project = "your-project-id";
    ByteString publicKeyBytes = ByteString.copyFrom(new byte[]{});
    String location = "ca-location";
    String poolId = "ca-poolId";
    String certificateAuthorityName = "certificate-authority-name";
    String certificateName = "certificate-name";

    createCertificate(
        project, location, poolId, certificateAuthorityName, certificateName, publicKeyBytes);
  }

  // Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
  // The public key used to sign the certificate can be generated using any crypto
  // library/framework.
  public static void createCertificate(
      String project,
      String location,
      String poolId,
      String certificateAuthorityName,
      String certificateName,
      ByteString publicKeyBytes)
      throws InterruptedException, ExecutionException, IOException {
    // 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()) {

      // commonName: Enter a title for your certificate.
      // orgName: Provide the name of your company.
      // domainName: List the fully qualified domain name.
      // certificateLifetime: The validity of the certificate in seconds.
      String commonName = "commonname";
      String orgName = "orgname";
      String domainName = "dns.example.com";
      long certificateLifetime = 1000L;

      // Set the Public Key and its format.
      PublicKey publicKey =
          PublicKey.newBuilder().setKey(publicKeyBytes).setFormat(KeyFormat.PEM).build();

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

      // Set the X.509 fields required for the certificate.
      X509Parameters x509Parameters =
          X509Parameters.newBuilder()
              .setKeyUsage(
                  KeyUsage.newBuilder()
                      .setBaseKeyUsage(
                          KeyUsageOptions.newBuilder()
                              .setDigitalSignature(true)
                              .setKeyEncipherment(true)
                              .setCertSign(true)
                              .build())
                      .setExtendedKeyUsage(
                          ExtendedKeyUsageOptions.newBuilder().setServerAuth(true).build())
                      .build())
              .setCaOptions(CaOptions.newBuilder().setIsCa(true).buildPartial())
              .build();

      // Create certificate.
      Certificate certificate =
          Certificate.newBuilder()
              .setConfig(
                  CertificateConfig.newBuilder()
                      .setPublicKey(publicKey)
                      .setSubjectConfig(subjectConfig)
                      .setX509Config(x509Parameters)
                      .build())
              .setLifetime(Duration.newBuilder().setSeconds(certificateLifetime).build())
              .build();

      // Create the Certificate Request.
      CreateCertificateRequest certificateRequest =
          CreateCertificateRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateId(certificateName)
              .setCertificate(certificate)
              .setIssuingCertificateAuthorityId(certificateAuthorityName)
              .build();

      // Get the Certificate response.
      ApiFuture<Certificate> future =
          certificateAuthorityServiceClient
              .createCertificateCallable()
              .futureCall(certificateRequest);

      Certificate response = future.get();
      // Get the PEM encoded, signed X.509 certificate.
      System.out.println(response.getPemCertificate());
      // To verify the obtained certificate, use this intermediate chain list.
      System.out.println(response.getPemCertificateChainList());
    }
  }
}

Python

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

def create_certificate(
    project_id: str,
    location: str,
    ca_pool_name: str,
    ca_name: str,
    certificate_name: str,
    common_name: str,
    domain_name: str,
    certificate_lifetime: int,
    public_key_bytes: bytes,
) -> None:
    """
    Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
    The key used to sign the certificate is created by the Cloud KMS.

    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 a unique name for the CA pool.
        ca_name: the name of the certificate authority which issues the certificate.
        certificate_name: set a unique name for the certificate.
        common_name: a title for your certificate.
        domain_name: fully qualified domain name for your certificate.
        certificate_lifetime: the validity of the certificate in seconds.
        public_key_bytes: public key used in signing the certificates.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    # The public key used to sign the certificate can be generated using any crypto library/framework.
    # Also you can use Cloud KMS to retrieve an already created public key.
    # For more info, see: https://cloud.google.com/kms/docs/retrieve-public-key.

    # Set the Public Key and its format.
    public_key = privateca_v1.PublicKey(
        key=public_key_bytes,
        format_=privateca_v1.PublicKey.KeyFormat.PEM,
    )

    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(common_name=common_name),
        subject_alt_name=privateca_v1.SubjectAltNames(dns_names=[domain_name]),
    )

    # Set the X.509 fields required for the certificate.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                digital_signature=True,
                key_encipherment=True,
            ),
            extended_key_usage=privateca_v1.KeyUsage.ExtendedKeyUsageOptions(
                server_auth=True,
                client_auth=True,
            ),
        ),
    )

    # Create certificate.
    certificate = privateca_v1.Certificate(
        config=privateca_v1.CertificateConfig(
            public_key=public_key,
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        lifetime=duration_pb2.Duration(seconds=certificate_lifetime),
    )

    # Create the Certificate Request.
    request = privateca_v1.CreateCertificateRequest(
        parent=caServiceClient.ca_pool_path(project_id, location, ca_pool_name),
        certificate_id=certificate_name,
        certificate=certificate,
        issuing_certificate_authority_id=ca_name,
    )
    result = caServiceClient.create_certificate(request=request)

    print("Certificate creation result:", result)

Demander un certificat à l'aide d'une clé Cloud KMS existante

Pour créer un certificat TLS de serveur d'entités finales à l'aide d'une clé Cloud KMS, exécutez la commande suivante:

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --kms-key-version projects/PROJECT_ID/locations/LOCATION_ID/keyRings/KEY_RING/cryptoKeys/KEY/cryptoKeyVersions/KEY_VERSION \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "leaf_server_tls"

Remplacez les éléments suivants :

POOL_ID: nom du pool d'autorités de certification.
PROJECT_ID : ID du projet
LOCATION_ID: emplacement du trousseau de clés
KEY_RING: nom du trousseau de clés où se trouve la clé.
KEY : nom de la clé.
KEY_VERSION: version de la clé.
CERT_FILENAME: chemin d'accès au fichier de chaîne de certificat encodé au format PEM. Le fichier de chaîne de certificats est classé de l'entité finale à la racine.
DNS_NAME: SAN DNS séparés par une virgule.

Effectuer des opérations courantes avec des certificats

Cette section explique comment effectuer certaines opérations courantes à l'aide de certificats.

Émettre un certificat à partir d'une autorité de certification spécifique dans un pool d'autorités de certification

gcloud

Pour cibler une autorité de certification spécifique dans le pool d'autorités de certification pour l'émission du certificat, ajoutez l'option --ca avec l'élément CA_ID de l'autorité de certification qui doit émettre le certificat.

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --ca CA_ID \
  --generate-key \
  --key-output-file KEY_FILENAME \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "leaf_server_tls"

Console

La console Google Cloud ne permet l'émission de certificats qu'à partir d'une autorité de certification particulière. Suivez les instructions de la section Demander un certificat à l'aide d'une clé générée automatiquement ou Demander un certificat à l'aide d'une requête de signature de certificat pour choisir l'autorité de certification qui doit émettre le certificat.

Terraform

resource "google_privateca_certificate_authority" "authority" {
  // 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-sample-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        is_ca = true
      }
      key_usage {
        base_key_usage {
          digital_signature = true
          cert_sign         = true
          crl_sign          = true
        }
        extended_key_usage {
          server_auth = true
        }
      }
    }
  }
  lifetime = "86400s"
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}

resource "google_privateca_certificate" "default" {
  pool     = "my-pool"
  location = "us-central1"
  lifetime = "860s"
  name     = "my-sample-certificate"
  config {
    subject_config {
      subject {
        common_name         = "san1.example.com"
        country_code        = "us"
        organization        = "google"
        organizational_unit = "enterprise"
        locality            = "mountain view"
        province            = "california"
        street_address      = "1600 amphitheatre parkway"
        postal_code         = "94109"
      }
    }
    x509_config {
      ca_options {
        is_ca = false
      }
      key_usage {
        base_key_usage {
          crl_sign = true
        }
        extended_key_usage {
          server_auth = true
        }
      }
    }
    public_key {
      format = "PEM"
      key    = base64encode(data.tls_public_key.example.public_key_pem)
    }
  }
  // Certificates require an authority to exist in the pool, though they don't
  // need to be explicitly connected to it
  depends_on = [google_privateca_certificate_authority.authority]
}

resource "tls_private_key" "example" {
  algorithm = "RSA"
}

data "tls_public_key" "example" {
  private_key_pem = tls_private_key.example.private_key_pem
}

Afficher les certificats émis

Console

Dans la console Google Cloud, accédez à la page Certificate Authority Service.

Accéder à Certificate Authority Service
Cliquez sur l'onglet Gestionnaire de CA.
Sur la page Autorités de certification, cliquez sur le nom de l'autorité de certification.
Au bas de la page de détails Autorité de certification, cliquez sur Afficher les certificats émis pour afficher la liste des certificats émis par l'autorité de certification.

Vous pouvez consulter les certificats sur la page Tous les certificats. Ces détails incluent l'état du certificat, l'autorité de certification émettrice, le pool d'autorités de certification qui contient l'autorité de certification, la date d'expiration du certificat, etc.

gcloud

Pour répertorier tous les certificats émis par une autorité de certification particulière dans un pool d'autorités de certification, utilisez la commande gcloud suivante:

gcloud privateca certificates list --issuer-pool ISSUER_POOL --ca CA_NAME

Pour plus d'informations sur la commande gcloud privateca certificates list, consultez la section gcloud privateca certificats list.

Pour répertorier tous les certificats de toutes les autorités de certification dans un emplacement donné, utilisez la commande gcloud suivante:

gcloud privateca certificates list --location LOCATION

Go

import (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
	"google.golang.org/api/iterator"
)

// List Certificates present in the given CA pool.
func listCertificates(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string) error {
	// projectId := "your_project_id"
	// location := "us-central1"		// For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
	// caPoolId := "ca-pool-id"			// The CA Pool id in which the certificate exists.

	ctx := context.Background()
	caClient, err := privateca.NewCertificateAuthorityClient(ctx)
	if err != nil {
		return fmt.Errorf("NewCertificateAuthorityClient creation failed: %w", err)
	}
	defer caClient.Close()

	fullCaName := fmt.Sprintf("projects/%s/locations/%s/caPools/%s", projectId, location, caPoolId)

	// Create the ListCertificatesRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#ListCertificatesRequest.
	req := &privatecapb.ListCertificatesRequest{Parent: fullCaName}

	it := caClient.ListCertificates(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("unable to get the list of cerficates: %w", err)
		}

		fmt.Fprintf(w, " - %s (common name: %s)", resp.Name,
			resp.CertificateDescription.SubjectDescription.Subject.CommonName)
	}

	return nil
}

Java


import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.Certificate;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import java.io.IOException;

public class ListCertificates {

  public static void main(String[] args) throws 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: Id of the CA pool which contains the certificates to be listed.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    listCertificates(project, location, poolId);
  }

  // List Certificates present in the given CA pool.
  public static void listCertificates(String project, String location, String poolId)
      throws IOException {
    // 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()) {

      CaPoolName caPool =
          CaPoolName.newBuilder()
              .setProject(project)
              .setLocation(location)
              .setCaPool(poolId)
              .build();

      // Retrieve and print the certificate names.
      System.out.println("Available certificates: ");
      for (Certificate certificate :
          certificateAuthorityServiceClient.listCertificates(caPool).iterateAll()) {
        System.out.println(certificate.getName());
      }
    }
  }
}

Python


import google.cloud.security.privateca_v1 as privateca_v1

def list_certificates(
    project_id: str,
    location: str,
    ca_pool_name: str,
) -> None:
    """
    List Certificates present 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: name of the CA pool which contains the certificates to be listed.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

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

    # Retrieve and print the certificate names.
    print(f"Available certificates in CA pool {ca_pool_name}:")
    for certificate in caServiceClient.list_certificates(parent=ca_pool_path):
        print(certificate.name)

Afficher les détails d'un seul certificat

Console

Dans la console Google Cloud, accédez à la page Certificate Authority Service.

Accéder à Certificate Authority Service
Sélectionnez votre autorité de certification cible dans l'onglet Gestionnaire de CA.
Cliquez sur le nom de l'autorité de certification.
Au bas de la page Autorité de certification, cliquez sur Afficher les certificats émis pour consulter la liste des certificats émis.
Cliquez sur dans la colonne Actions du certificat que vous souhaitez télécharger.
Sous Télécharger, cliquez sur Certificat. Vous pouvez télécharger la chaîne de certificats en cliquant sur Chaîne de certificats.

gcloud

Pour afficher la description complète d'un certificat, exécutez la commande suivante:

gcloud privateca certificates describe CERT_NAME \
    --issuer-pool POOL_ID

Pour plus d'informations sur la commande gcloud privateca certificates describe, consultez la page gcloud privateca certificate describe.

Pour exporter la chaîne de certificats X.509 encodée au format PEM et vers un fichier, exécutez la commande suivante:

gcloud privateca certificates export CERT_NAME \
    --issuer-pool POOL_ID \
    --include-chain \
    --output-file certificate-file

Pour plus d'informations sur la commande gcloud privateca certificates export, consultez la section gcloud privateca certificate export.

Preuve de possession des certificats

La preuve de possession de la clé privée permet de s'assurer que le demandeur d'un certificat détient la clé privée correspondant à ce certificat. Le service CA vérifie la preuve de possession uniquement si le demandeur fournit une requête de signature de certificat PKCS #10 conformément au document RFC 2986. Pour les autres formes de demandes de certificat, telles que les demandes par CertificateConfig, la preuve de possession n'est pas appliquée.

Il est de la responsabilité des applications clientes qui acceptent les certificats de vérifier si le titulaire du certificat possède la clé privée de ce certificat. Mettre en place des vérifications de preuve de possession lors de l'émission du certificat constitue une forme de défense en profondeur visant à protéger les clients en cas de comportement défaillant. L’existence de ces clients, que l’autorité de certification vérifie ou non la preuve de possession, pourrait constituer une faille de sécurité.

Étapes suivantes

En savoir plus sur les profils de certificat
Découvrez comment révoquer des certificats.
Découvrez comment trier et filtrer les certificats.
Découvrez comment gérer des certificats à l'aide de la Google Cloud CLI.

Demander un certificat et afficher les certificats émis

Avant de commencer

Présentation

Demander un certificat à l'aide d'une requête de signature de certificat

Console

gcloud

Terraform

API REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

Demander un certificat à l'aide d'une clé générée automatiquement

Console

gcloud

Go

Java

Python

Demander un certificat à l'aide d'une clé Cloud KMS existante

Effectuer des opérations courantes avec des certificats

Émettre un certificat à partir d'une autorité de certification spécifique dans un pool d'autorités de certification

gcloud

Console

Terraform

Afficher les certificats émis

Console

gcloud

Go

Java

Python

Afficher les détails d'un seul certificat

Console

gcloud

Preuve de possession des certificats

Étapes suivantes